线程同步

1. 线程同步

当一个线程修改变量时，其他线程在读取这个变量的值时就可能看到不一致的数据。在变量修改时间多于一个存储器访问周期的处理器结构中，当存储器读与存储器写这两个操作交叉进行，这种潜在的不一致就会出现。所以，当两个线程或多个线程试图对在同一时间修改或读取同一变量时，就需要同步。例如增量操作，它可以分成三步：

1) 从内存单元读入寄存器

2) 在寄存器中进行变量值的增加

3) 把新的值写回内存单元

除了计算机体系结构的因素外，程序使用变量的方式也会引起竞争。

 

1.1. 互斥量

互斥量(mutex)从本质上是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。在设计时需要规定所有线程必须遵守相同的数据访问规则，只有这样，互斥机制才能正常工作。

互斥变量用pthread_mutex_t数据类型表示，在使用互斥变量以前，必须对它进行初始化，可以把它置为PTHREAD_MUTEX_INITIALIZER(只对静态分配的互斥量)，也可以通过调用pthread_mutex_init函数进行初始化。如果是动态分配互斥量(malloc),那么在释放内存前需要调用pthread_mutex_destroy函数。

#include <pthread.h>

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

int pthread_mutex_destroy(pthread_mutex_t *mutex);

对互斥量进行加锁，需要调用pthread_mutex_lock，如果互斥量已经上锁，地哦阿姨线程将阻塞直到互斥量被解锁。对互斥量解锁，需要调用pthread_mutex_unlock。

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutes);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁。如果调用pthread_mutex_trylock时互斥量处于未锁住状态，那么pthread_mutex_trylock将锁住互斥量，不会出现阻塞并返回0，否则pthread_mutex_trylock就会失败，不能锁住互斥量，而返回EBUSY。

 

1.2. 避免死锁

如果线程试图对同一互斥量加锁两次，那么它自身就会陷入死锁状态，使用互斥量时，还有其他更不明显的方式也能产生死锁。如果两个线程都在相互请求另一个线程拥有的资源，那么这两个线程都无法向前运行，就会产生死锁。如果一个线程试图以与另一个线程相反的顺序锁住互斥变量时，就可能出现死锁。

有两种方案可以避免死锁的发生：一是控制互斥量的加锁顺序，二是使用pthread_mutex_trylock接口避免死锁。如果已经占有某些锁而且pthread_mutex_trylock接口返回成功，那么就可以前进，但是，如果不能获取锁，可以先释放已经占有的锁，做好清理工作，然后过一段时间重新尝试。

多线程的软件设计需要经常考虑这种折中处理方案。如果锁的粒度太粗，就会出现很多线程阻塞等待相同的锁，源自并发性的改善微乎其微。如果锁的粒度太细，那么过多的所开销会使系统性能受到影响，而且代码变得相当复杂。

 

1.3. 读写锁

读写锁与互斥量类似，不过读写锁有三种状态：读模式下加锁状态，写模式下加锁状态，不加锁状态。一次只有一个线程可以占有写模式下的读写锁，但是多个线程可以同时占有读模式下的读写锁。

当读写锁是写加锁状态时，在这个被解锁之前，所有试图对这个锁加锁的线程都会被阻塞。当读写锁在读加锁状态时，所有试图以读模式对它进行加锁的线程都可以得到访问权，但是如果线程希望以写模式对此进行加锁，它必须阻塞直到所有线程释放度锁，同时读写锁会阻塞随后的读模式锁请求。读写锁非常适合于对数据结构读的次数远大于写的情况。

与互斥量一样，读写在使用之前必须初始化，在释放它们底层的内存前必须销毁。

int pthread_rwlock_init(pthread_rwlock_t * restrict rwlock,

const pthread_rwlock_t *restrict attr);

int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

读写锁通过调用pthread_relock_init进行初始化。如果希望读写锁有默认的属性，可以传一个空指针给attr。

int pthread_rwlock_rdlock(pthread_rwlock_t *relock);

int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

要在读模式下锁定读写锁，需要调用pthread_rwlock_rdlock；需要在写模式锁定读写锁，需要调用pthread_rwlock_rwlock。不管以何种方式锁住读写锁，都可以调用pthread_rwlock_unlock进行解锁。在实现读写锁的时候可能会对共享模式下可获取的锁的数量有限制，所以需要检查pthread_relock_rdlock的返回值。

Single UNIX Specification同样定义了有条件的读写锁原语的版本。

int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

int pthread_rwlock_tryrwlock(pthread_rwlock_t * rwlock);

可以获取锁时，函数返回0，否则返回错误EBUSY。

 

1.4. 条件变量

条件变量时线程可用的另一种同步机制。条件变量给多个线程提供了一个会合的场所。条件变量与互斥量一起使用时，允许线程以无竞争的方式等待特定的条件发生。

条件本身是由互斥量保护。线程在改变条件状态前必须锁住互斥量，其它线程在获得互斥量之前不会察觉到这种改变，因为必须锁定互斥量以后才能计算条件。

条件变量使用之前必须首先进行初始化，pthread_cond_t数据类型代表的条件变量可以用两种方式进行初始化，可以把常量PTHREAD_COND_INITIALIZE赋给静态分配的条件变量，但是如果条件变量时动态分配的，可以用pthread_cond_init函数初始化。

在释放底层内存空间之前，pthread_cond_destroy函数对条件变量进行去除初始化(deinitialize)。

int pthread_cond_init(pthread_cond_t *restrict cond,

pthread_condattr_t *restrict attr);

int pthread_cond_destroy(pthread_cond_t *cond);

使用pthread_cond_wait等待条件变为真，如果在给定的时间内条件不能满足，那么会生成一个出错码的返回变量。

int pthread_cond_wait(pthread_cond_t *restrict cond,

pthread_mutex_t *restrict mutex);

int pthread_cond_timedwait(pthread_cond_t *restrict cond,

pthread_mutex_t *restrict mutex,

const struct timespec *restrict timeout);

传递pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的互斥量传给函数。函数吧调用线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作是原子操作。这样就关闭了条件检查和线程进入休眠状态等待条件改变这两个操作之间的时间通道，这样线程就不会错过条件的任何变化。pthread_cond_wait返回时，互斥量再次被锁住。

pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数相似，只是多个timeout。Timeout值指定了等待的时间，它是通过timespec结构指定。时间值用秒数或者分秒数来表示，分秒数的单位是纳秒。

struct timespec {

    time_t tv_sec;    /*seconds*/

    long   tv_nsec;   /*nancsenconds*/

};

使用这个结构时，需要指定愿意等待多长时间，时间值是一个绝对值而不是相对数。例如，如果能等待3分钟，就需要把当前时间加上3分钟再转换到timespec结构，而不是把3三分钟转换成timespec结构。

可使用gettimeofday获取timeval结构表示的当前时间，然后把这个时间转换成timespec结构。要得到timeout值的绝对时间，可以使用下面的函数：

void maketimeout（struct timespec *tsp,long minutes

{

  struct timeval now;

  gettimeofday(&now);

  tsp->tv_sec = now.tv_sec;

  tsp->tv_nsec = now.tv_usec*1000;/* usec to nsec /

  tsp->tv_sec+=minutes*60;/*add the offset to get timeout value*/

}

如果时间值得到了但是条件还是没有出现，pthread_cond_timedwait将重新获取互斥量然后返回ETIMROUT。从pthread_cond_wait或pthread_cond_timedwait调用成功返回时，线程需要重新计算条件，因为其他线程可能已经在运行并改变条件。

有两个函数可以用于通知条件已经满足。pthread_cond_signal函数将唤醒等待该条件的某个线程，而pthread_cond_broadcast函数将唤醒等待该条件的所有线程。

int pthread_cond_signal(pthread_cond_t *cond);

int pthread_cond_broadcast(pthread_cond_t *cond);

调用pthread_cond_signal或pthread_cond_broadcast，也称为向线程或条件发送信号。必须注意一定要在改变条件以后再给线程发送信号。

 

实例(使用条件变量)

条件是工作队列的状态。用互斥量保护条件，在while循环中判断条件。把消息放到工作队列时，需要占有互斥量，但向等待线程发送信号时并不需要占有互斥量。只要线程可以在调用pthread_cond_signal之前把消息队列中拖出，就可以在释放互斥量以后再完成这部分工作。因为是在while循环中检查条件，所以不会存在问题：线程醒来，发现队列仍为空，然后返回继续等待。如果代码不能容忍这种竞争，就需要在向线程发送信号的时候占有互斥量。

typedef struct msgInfo { struct msgInfo *m_next; /* 其它信息 */ } msg_info_s; msg_info_s *workqu; pthread_cond_t qready = PTHREAD_COND_INITIALIZER; pthread_mutex_t qlock = PTHREAD_MUTEX_INITIALIZER; void proccess_msg(void) { msg_info_s *p_msg; for(;;) { pthread_mutex_lock(&qlock); while(NULL == workqu) { pthread_cond_wait(&qready, &qlock); } p_msg = workqu; workqu = p_msg->m_next; pthread_mutex_unlock(&qlock); } /* now proccess the message p_msg*/ } void enqueue_msg(msg_info_s *p_msg) { pthread_mutex_lock(&qlock); p_msg->m_next = workqu; workqu = p_msg; pthread_mutex_unlock(&qlock); pthread_cond_signal(&qready); }