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

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

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

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

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

static int g_n = 0;

static void *
thread_routine(void *arg)
{
    int n_loops = (int)(arg);
    int loc;
    int j;
    
    for (j = 0; j < n_loops; j++)
    {
        loc = g_n;
        loc++;
        g_n = loc;
    }
    
    return 0;
}

int
main(int argc, char *argv[])
{
    int n_loops, s;
    pthread_t t1, t2;
    void *args[2];
    
    n_loops = (argc > 1) ? atoi(argv[1]) : 10000000;
    
    args[0] = (void *)n_loops;
    s = pthread_create(&t1, 0, thread_routine, &args);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_create(&t2, 0, thread_routine, &args);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t1, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t2, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }

    printf("Loops [%d] times by 2 threads without critical section.
", n_loops);
    printf("Var g_n is [%d].
", 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 = 0;
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 = 0; j < n_loops; j++)
    {
        s = pthread_mutex_lock(&mtx);
        if (s != 0)
        {
            perror("error pthread_mutex_lock.
");
            exit(EXIT_FAILURE);
        }
        
        loc = g_n;
        loc++;
        g_n = loc;
        
        s = pthread_mutex_unlock(&mtx);
        if (s != 0)
        {
            perror("error pthread_mutex_unlock.
");
            exit(EXIT_FAILURE);
        }
    }
    
    return 0;
}

int
main(int argc, char *argv[])
{
    pthread_t t1, t2;
    int n_loops, s;
    
    n_loops = (argc > 1) ? atoi(argv[1]) : 10000000;
    
    s = pthread_create(&t1, 0, thread_routine, &n_loops);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_create(&t2, 0, thread_routine, &n_loops);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t1, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t2, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }

    printf("Var g_n is [%d].
", 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 = 0;

static void *
thread_routine(void *arg)
{
    void **args = (void **)arg;
    int n_loops = (int)(args[0]);
    int loc;
    int j;
    int s;
    pthread_mutex_t *mtx = (pthread_mutex_t *)(args[1]);
    
    for (j = 0; j < n_loops; j++)
    {
        s = pthread_mutex_lock(mtx);
        if (s != 0)
        {
            printf("error pthread_mutex_lock. return:[%d] errno:[%d]
", s, errno);
            exit(EXIT_FAILURE);
        }
        
        loc = g_n;
        loc++;
        g_n = loc;
        
        s = pthread_mutex_unlock(mtx);
        if (s != 0)
        {
            perror("error pthread_mutex_unlock.
");
            exit(EXIT_FAILURE);
        }
    }
    
    return 0;
}

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[2];
    
    s = pthread_mutexattr_init(&mtx_attr);
    if (s != 0)
    {
        perror("error pthread_mutexattr_init.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_mutexattr_settype(&mtx_attr, PTHREAD_MUTEX_ERRORCHECK);
    if (s != 0)
    {
        perror("error pthread_mutexattr_settype.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_mutex_init(&mtx, &mtx_attr);
    if (s != 0)
    {
        perror("error pthread_mutex_init.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_mutexattr_destroy(&mtx_attr);
    if (s != 0)
    {
        perror("error pthread_mutexattr_destroy.
");
        exit(EXIT_FAILURE);
    }
    
    n_loops = (argc > 1) ? atoi(argv[1]) : 10000000;
    
    args[0] = (void *)n_loops;
    args[1] = (void *)&mtx;
    s = pthread_create(&t1, 0, thread_routine, &args);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_create(&t2, 0, thread_routine, &args);
    if (s != 0)
    {
        perror("error pthread_create.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t1, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_join(t2, 0);
    if (s != 0)
    {
        perror("error pthread_join.
");
        exit(EXIT_FAILURE);
    }
    
    s = pthread_mutex_destroy(&mtx);
    if (s != 0)
    {
        perror("error pthread_mutex_destroy.
");
        exit(EXIT_FAILURE);
    }
    
    printf("Var g_n is [%d].
", 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章的内容，版权相关的问题请联系作者或者相应的出版社。