Linux/Unix 线程同步技术之互斥量(1)

众所周知，互斥量(mutex)是同步线程对共享资源访问的技术，用来防止下面这种情况：线程A试图访问某个共享资源时，线程B正在对其进行修改，从而造成资源状态不一致。与之相关的一个术语临界区（critical section）是指访问某一共享资源的代码片段，并且这段代码的执行为原子(atomic)操作，即同时访问同一共享资源的其他线程不应中断该片段的执行。

我们先来看看不使用临界区技术保护共享资源的例子，该例子使用2个线程来同时递增同一个全局变量。

代码示例1：不使用临界区技术访问共享资源

 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>

 static int g_n = ;

 static void *
 thread_routine(void *arg)
 {
     int n_loops = (int)(arg);
     int loc;
     int j;

     for (j = ; j < n_loops; j++)
     {
         loc = g_n;
         loc++;
         g_n = loc;
     }

     return ;
 }

 int
 main(int argc, char *argv[])
 {
     int n_loops, s;
     pthread_t t1, t2;
     void *args[];

     n_loops = (argc > ) ? atoi(argv[]) : ;

     args[] = (void *)n_loops;
     s = pthread_create(&t1, , thread_routine, &args);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_create(&t2, , thread_routine, &args);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t1, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t2, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     printf("Loops [%d] times by 2 threads without critical section.\n", n_loops);
     printf("Var g_n is [%d].\n", g_n);
     exit(EXIT_SUCCESS);
 }

运行以上代码生成的程序，若循环次数较少，比如每个线程都对全局变量g_n递增1000次，结果看起来很正常：

$ ./thdincr_nosync 1000
Loops [1000] times by 2 threads without critical section.
Var g_n is [2000].

如果加大每个线程的循环次数，结果将大不相同：

$ ./thdincr_nosync 10000000
Loops [10000000] times by 2 threads without critical section.
Var g_n is [18655665].

造成以上问题的原因在于下面的执行序列：

1. 线程1将g_n的值赋给局部变量loc。假设g_n的当前值为1000。

2. 线程1的时间片用尽，线程2开始执行。

3. 线程2执行多次循环:将g_n的值改为其他的值，例如3000，线程2的时间片用尽。

4. 线程1重新获得时间片，并从上次停止处恢复执行。线程1在上次运行时，已将g_n的值（1000）赋给loc，现在递增loc，再将loc的值1001赋给g_n。此时线程2之前递增操作的结果遭到覆盖。

如果使用上面同样的命令行参数运行该程序多次，g_n的值会出现很大波动：

$ ./thdincr_nosync 10000000
Loops [10000000] times by 2 threads without critical section.
Var g_n is [14085995].

$ ./thdincr_nosync 10000000
Loops [10000000] times by 2 threads without critical section.
Var g_n is [13590133].

$ ./thdincr_nosync 10000000
Loops [10000000] times by 2 threads without critical section.
Var g_n is [20000000].

$ ./thdincr_nosync 10000000
Loops [10000000] times by 2 threads without critical section.
Var g_n is [16550684].

这一行为结果的不确定性，原因在于内核CPU调度顺序的不可预测性。若在复杂的程序中发生这种不确定结果的行为，意味着此类错误将偶尔发作，难以复现，因此也很难发现。如果使用如下语句：

g_n++;        /* 或者: ++g_n */

来替换thread_routine内for循环中的3条语句，似乎可以解决这一问题，不过在很多硬件架构上，编译器在将这条语句转换成机器码时，其效果仍等同于原先thread_routine内for循环中的3条语句。即换成一条语句并非意味着该操作就是原子操作。

为了避免上述同一行为的结果不确定性，必须使用某种技术来确保同一时刻只有一个线程可以访问共享资源，在Linux/Unix系统中，互斥量mutex(mutual exclusion的缩写)就是为这种情况设计的一种线程间同步技术，可以使用互斥量来保证对任意共享资源的原子访问。

互斥量有两种状态：已锁定和未锁定。任何时候，至多只有一个线程可以锁定该互斥量。试图对已经锁定的互斥量再次加锁，将可能阻塞线程或者报错，具体取决于加锁时使用的方法。

静态分配的互斥量：

互斥量既可以像静态变量那样分配，也可以在运行时动态创建，例如，通过malloc在堆中分配，或者在栈上的自动变量，下面的语句展示了如何初始化静态分配的互斥量：

static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

互斥量的加锁和解锁操作：

初始化之后，互斥量处于未锁定状态。函数pthread_mutex_lock()可以锁定某一互斥量，而函数pthread_mutex_unlock()可以将一个已经锁定的互斥量解锁。

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);

/* 两个函数在成功时返回值为0，失败时返回一个正值代表错误号。 */

代码示例2：使用静态分配的互斥量保护对全局变量的访问

 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>

 static int g_n = ;
 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

 static void *
 thread_routine(void *arg)
 {
     int n_loops = *((int *)arg);
     int loc;
     int j;
     int s;

     for (j = ; j < n_loops; j++)
     {
         s = pthread_mutex_lock(&mtx);
         if (s != )
         {
             perror("error pthread_mutex_lock.\n");
             exit(EXIT_FAILURE);
         }

         loc = g_n;
         loc++;
         g_n = loc;

         s = pthread_mutex_unlock(&mtx);
         if (s != )
         {
             perror("error pthread_mutex_unlock.\n");
             exit(EXIT_FAILURE);
         }
     }

     return ;
 }

 int
 main(int argc, char *argv[])
 {
     pthread_t t1, t2;
     int n_loops, s;

     n_loops = (argc > ) ? atoi(argv[]) : ;

     s = pthread_create(&t1, , thread_routine, &n_loops);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_create(&t2, , thread_routine, &n_loops);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t1, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t2, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     printf("Var g_n is [%d].\n", g_n);
     exit(EXIT_SUCCESS);
 }

运行此示例代码生成的程序，从结果中可以看出对g_n的递增操作总能保持正确：

$ ./thdincr_mutex 10000000
Var g_n is [20000000].
$ ./thdincr_mutex 10000000
Var g_n is [20000000].
$ ./thdincr_mutex 10000000
Var g_n is [20000000].
$ ./thdincr_mutex 10000000
Var g_n is [20000000].
$ ./thdincr_mutex 10000000
Var g_n is [20000000].

代码示例3：使用动态分配的互斥量保护对全局变量的访问

 #include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>

 static int g_n = ;

 static void *
 thread_routine(void *arg)
 {
     void **args = (void **)arg;
     int n_loops = (int)(args[]);
     int loc;
     int j;
     int s;
     pthread_mutex_t *mtx = (pthread_mutex_t *)(args[]);

     for (j = ; j < n_loops; j++)
     {
         s = pthread_mutex_lock(mtx);
         if (s != )
         {
             printf("error pthread_mutex_lock. return:[%d] errno:[%d]\n", s, errno);
             exit(EXIT_FAILURE);
         }

         loc = g_n;
         loc++;
         g_n = loc;

         s = pthread_mutex_unlock(mtx);
         if (s != )
         {
             perror("error pthread_mutex_unlock.\n");
             exit(EXIT_FAILURE);
         }
     }

     return ;
 }

 int
 main(int argc, char *argv[])
 {
     int n_loops, s;
     pthread_t t1, t2;
     pthread_mutex_t mtx;
     pthread_mutexattr_t mtx_attr;
     void *args[];

     s = pthread_mutexattr_init(&mtx_attr);
     if (s != )
     {
         perror("error pthread_mutexattr_init.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_ERRORCHECK);
     if (s != )
     {
         perror("error pthread_mutexattr_settype.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_mutex_init(&mtx, &mtx_attr);
     if (s != )
     {
         perror("error pthread_mutex_init.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_mutexattr_destroy(&mtx_attr);
     if (s != )
     {
         perror("error pthread_mutexattr_destroy.\n");
         exit(EXIT_FAILURE);
     }

     n_loops = (argc > ) ? atoi(argv[]) : ;

     args[] = (void *)n_loops;
     args[] = (void *)&mtx;
     s = pthread_create(&t1, , thread_routine, &args);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_create(&t2, , thread_routine, &args);
     if (s != )
     {
         perror("error pthread_create.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t1, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_join(t2, );
     if (s != )
     {
         perror("error pthread_join.\n");
         exit(EXIT_FAILURE);
     }

     s = pthread_mutex_destroy(&mtx);
     if (s != )
     {
         perror("error pthread_mutex_destroy.\n");
         exit(EXIT_FAILURE);
     }

     printf("Var g_n is [%d].\n", g_n);
     exit(EXIT_SUCCESS);
 }

多次运行示例3代码生成的程序会看到与示例2代码的程序同样的结果。

本文展示了Linux/Unix线程间同步技术---互斥量的基本功能和基础使用方法，在后面的文章中将会讨论互斥量的其他内容，如锁定互斥量的另外2个API: pthread_mutex_trylock()和pthread_mutex_timedlock() ，互斥量的性能，互斥量的死锁等。欢迎大家参与讨论。

本文参考了Michael Kerrisk的著作《The Linux Programming Interface》（中文版名为：Linux/Unix系统编程手册）第30章的内容，版权相关的问题请联系作者或者相应的出版社。