Linux的线程同步对象：互斥量Mutex，读写锁，条件变量

 

 

 

进程是Linux资源分配的对象，Linux会为进程分配虚拟内存（4G）和文件句柄等 资源，是一个静态的概念。线程是CPU调度的对象，是一个动态的概念。一个进程之中至少包含有一个或者多个线程。这些线程共享该进程空间的内存和文件句柄 资源，多个线程竞争地获得这些资源。为了防止多个线程访问资源的不一致性，多线程编程一个很重要的任务就是控制好线程同步。本文简单介绍一下Linux的 同步对象和使用时的一些注意事项。

1、互斥量（Mutex）

     互斥量本质上讲是一把锁，该锁保护一个或者一些资源（内存或者文件句柄等数据）。一个线程如果需要访问该资源必须要获得互斥量，并对其加锁。这时如果其他 线程如果想访问该资源也必须要获得该互斥量，但是锁已经加锁，所以这些进程只能阻塞，直到获得该锁的线程解锁。这时阻塞的线程里面有一个线程获得该互斥量 并加锁，获准访问该资源。其他的线程继续阻塞，周而复始。

     Linux互斥量句柄为pthread_mutex_t。可以以PTHREAD_MUTEX_INITIALIZER初始化一个互斥量，或者调用如下函数动态进行初始化：

#include <pthread.h>

int pthread_mutex_init(pthread_mutex_t *restrict mutex,
       const pthread_mutexattr_t *restrict attr);

销毁一个互斥量调用如下函数：

#include <pthread.h>

int pthread_mutex_destroy(pthread_mutex_t *mutex);

对一个互斥量加锁和解锁函数如下：

       #include <pthread.h>

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

     当前线程调用pthread_mutex_lock函数时，如果该互斥量未加锁，则当前线程获得该互斥量并解锁，该函数返回；如果当前该互斥量已经加锁，则该函数将会阻塞，直到该互斥量解锁，当前线程获得该互斥量，并加锁返回。

     pthread_mutex_trylock如果互斥量为未加锁，则当前线程将会获得该互斥量并加锁。当互斥量为加锁状态，该函数将会立即返回错误EBUSY，不会阻塞当前线程。

     互斥量的解锁函数为pthread_mutex_unlock，这样将会释放互斥量资源。

     另外注意一个问题就是互斥量死锁（dead lock）的问题。当一个互斥量的时候，不会发生互斥量的问题。当有多个互斥量的时候，有可能发生死锁。例如：有互斥量A，B。假如第一个线程获得互斥量 A，并加锁，这时他尝试获得互斥量B，但是互斥量B已经加锁，该线程被阻塞，等待互斥量B。同时另外一个线程先获得互斥量B，并已加锁。这时尝试获得互斥 量A，发现互斥量A已经加锁，则阻塞该线程，等待互斥量A。这样出现两个线程互相等待对方已经获得的信号量的问题，都处于阻塞状态，出现死锁。那么怎样解 决这种死锁问题呢？那就是线程以同样的顺序获得互斥量。第一个线程先获得互斥量A，再获得互斥量B；第二个线程也以同样的顺序获得互斥量。这样就不会出现 死锁的状态了。

      但是在一些结构复杂的程序中，很难保证以同样的顺序获得互斥量，那么怎样解决死锁问题呢？就是以pthread_mutex_trylock来尝试获得互斥量，如果不能获得互斥量，则释放已经持有的互斥量。过段时间，再次进行同样的尝试，这样可以避免死锁。

 

2 读写锁

如果多个线程同时读资源，则不会发生竞争关系，也不会出现资源的不一致性，所以读资源的时候不需要同步对象保护。但是如果写某个资源的时候，必须要进行同 步保护，否则将会出现不一致性。在上文的互斥量中，不管读写都加锁，这样对于读资源操作非常多，但写资源非常少的情况下，效率会比较低。Linux提供了 读写锁来解决这种情况下的效率问题。

     读写锁分为读锁定状态和写锁定状态，多个线程可以同时获得读锁定状态锁，进行各自的读操作。但是写锁定状态只能有一个线程获得，其他的线程线程的读锁定请求和写锁定请求都将会阻塞，直到当前的写锁定状态释放。

     创建和销毁读写锁用如下函数：

       #include <pthread.h>

       int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
       int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock,
              const pthread_rwlockattr_t *restrict attr);

     为读写锁加读锁定状态函数如下：

       #include <pthread.h>

       int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_rdlock若当前读写锁为未加锁状态或者为读锁定状态，该函数都可以获得读写锁并返回；若该读写锁为写锁定状态，则该函数将阻塞调用线程，直到该读写锁的写锁定状态释放。pthread_rwlock_tryrdlock若当前读写锁为未加锁状态或者为读锁定状态，该函数都可以获得读写锁并返回；若该读写锁为写锁定状态，则该函数将立即返回错误（错误码为EBUSY），不阻塞调用线程。

     为读写锁加写锁定状态的函数如下：

       #include <pthread.h>

       int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
       int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

pthread_rwlock_wrlock如果当前读写锁状态为未锁定，则该函数锁定该锁，并立即返回；如果该锁的状态为读锁定状态或者写锁定状态，则该函数将阻塞调用线程，直到该锁的读写状态被释放。pthread_rwlock_trywrlock如果当前读写锁状态为未锁定锁定，则该函数锁定该锁，并立即返回；如果该锁的状态为读锁定状态或者写锁定状态，则该函数立即返回，并返回错误码EBUSY，不阻塞调用线程。

     解除读写锁的锁定状态函数如下：

       #include <pthread.h>

       int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

不管是读锁定状态和写锁定状态都调用这个函数接触锁定。

 

3， 条件变量

在前面介绍了Linux下的互斥量和读写锁两种线程同步对象。这两种线程同步对象都是用来保护特定资源（内存，文件句柄等）的。假如某个线程需要等待系统处于某种状态下才能继续执行，Linux为了解决这种问题引入了条件变量这种线程同步对象，本文简要介绍一下条件变量。

      条件变量必须要与互斥量一起使用时，允许线程以无竞争的方式等待特定条件的发生。线程在等待条件变量和通知条件变量之前都必须要先把保护条件变量的互斥量加锁。

     和其他线程同步对象一样，条件变量一样需要初始化和销毁，函数定义如下：

       #include <pthread.h>

       int pthread_cond_destroy(pthread_cond_t *cond);
       int pthread_cond_init(pthread_cond_t *restrict cond,
              const pthread_condattr_t *restrict attr);
       pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

条件变量可以用PTHREAD_COND_INITIALIZER常量初始化，或者调用pthread_cond_init函数初始化。销毁调用pthread_cond_destroy。

     线程等待条件变量的函数定义如下：

       #include <pthread.h>

       int pthread_cond_timedwait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex,
              const struct timespec *restrict abstime);
       int pthread_cond_wait(pthread_cond_t *restrict cond,
              pthread_mutex_t *restrict mutex);

两个函数的差别在于前者指定一个超时时间，在该时间内阻塞调用线程，并等待条件变量，如果规定时间内条件还没有发生，则函数返回，并返回错误值ETIMEDOUT；而后者会一直阻塞调用线程，直到条件发生。

     这个等待函数的使用有一些需要注意的地方，就是首先调用这两个函数之前首先要对保护这个条件变量的互斥量加锁，然后用这个加锁的互斥量作为参数调用条件变 量等待函数。在等待函数内部将会对该互斥量解锁，为什么要对互斥量解锁呢？前面提到条件发生时，通知条件变量这个动作也是在这个互斥量保护之下的，加入这 个互斥量不释放，那么它等待的条件永远都不会发生了，将会进入死锁状态。马上讲到条件变量的通知函数。

    典型条件变量的等待调用如下：1）对互斥量加锁。2）用该互斥量做参数，调用等待条件变量的函数。3）条件发生之后，处理该条件。4）对该互斥量解锁。

     当某个条件变量已经满足，可以调用如下函数来激活等待线程。

       #include <pthread.h>

       int pthread_cond_broadcast(pthread_cond_t *cond);
       int pthread_cond_signal(pthread_cond_t *cond);

pthread_cond_signal将会激活等待线程中的一个；pthread_cond_broadcast将会激活所有的线程。另外请注意这两个函数也需要互斥量来保护。

      典型的条件变量激活调用方法如下：1）对互斥量加锁。2）修改条件，做自己该做的事儿。3）释放互斥量。4）调用上面两个函数通知等待线程。

     上面四个步骤中请注意3和4，千万不要搞反了，否则将会出现错误，等待函数可能会得不到执行（因为有线程竞争，后果未知）。具体原因请自行分析。