1.互斥量

当多个控制线程共享相同的内存时，需要确保每一个线程看到一致数据视图。如果不存在读取数据或者所有数据只读时不会存在一致性问题。如果某个线程正在修改变量而其他线程也可以读取或者修改这个变量的时候就需要对这些线程进行同步。在变量修改多于一个存储器访问周期时可能出现不一致的错误。（例如需要写的十一个长类型，需要多次写入内存。而写之间如果有其他线程读取就会出现同时读取一些修改过和没修改过的数据）。
通过使用pthread的互斥接口保护数据，确保同一时间只有一个线程访问数据。互斥量mutex本质上是一把锁，在访问共享资源前对互斥量加锁，然后其他任何试图访问互斥量加锁的线程将会被阻塞。访问完成后释放互斥量上的锁，被阻塞的线程将会变成可运行状态。同理，第一个变为可运行状态的进程将会锁住信号量，这样后面要访问该互斥量线程会被继续阻塞，直到回去再次等待它重新变为可用。
互斥量用pthread_mutex_t数据类型表示，在使用互斥量以前，必须首先对它进行初始化，可以把它置为常量PTHREAD_MUTEX_INITIALIZER(只对静态分配的互斥量)或者使用pthread_mutex_init函数进行初始化。如果动态分配(malloc)那么释放内存前需要调用(pthread_mutex_destroy)
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
int pthread_mutex_destory(pthread_mutex_t *mutex);
要使用默认的属性初始化互斥量，只需要将attr设置为NULL。非默认的互斥量属性
<<Chapter 12.4>>
对互斥量进行加锁，需要调用pthread_mutex_lock,如果互斥量已经上锁，调用线程将阻塞直到互斥量被解锁。对互斥量解锁需要调用pthread_mutex_unlock。
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
/*成功返回0，失败则返回错误编号*/
如果线程不希望被阻塞，它可以使用pthread_mutex_trylock尝试对互斥量进行加锁，成功加锁（原来未被锁住）则返回0，失败则不会被阻塞，直接返回EBUSY。
下面是一个×××信号量的实现，当线程需要对这个对象时则对引用计数加1，当对象使用完毕时，需要对引用计数减1.当最后一个引用被释放时，对象所占空间就会被释放。
 
  1. #include <stdlib.h> 
  2. #include <pthread.h> 
  3. struct foo { 
  4.     int f_count; 
  5.     pthread_mutex_t f_lock; 
  6.     }; 
  7.  
  8. struct foo * 
  9. foo_alloc(void) /* allocate the object */ 
  10. { 
  11.     struct foo *fp; 
  12.     if ((fp = malloc(sizeof(struct foo)))!=NULL) { 
  13.         fp->count = 1; 
  14.         if (pthread_mutex_init(&fp->lock, NULL) != 0) { 
  15.             free(fp); 
  16.             return NULL; 
  17.         } 
  18.         /* continue initialization */ 
  19.     } 
  20.     return fp; 
  21. } 
  22.  
  23. void 
  24. foo_add(struct foo *fp) {   /* add an reference to this object */ 
  25.     pthread_mutex_lock(&fp->f_lock); 
  26.     fp->count++; 
  27.     pthread_mutex_unlock(&fp->f_lock); 
  28. } 
  29.  
  30. void 
  31. foo_rele(struct foo *fp) {  /* release a reference to the object */ 
  32.     pthread_mutex_lock(&fp->f_lock); 
  33.     if (--fp->f_count == 0) /* last reference */ 
  34.         pthread_mutex_unlock(&fp->f_lock); 
  35.         pthread_mutex_destroy(&fp->f_lock); 
  36.         free(fp); 
  37.     } else { 
  38.         pthread_mutex_unlock(&fp->f_lock); 
  39.     } 
  40. } 
 
2. 读写锁
    读写锁与mutex类似，不过读写锁允许更高的并行性。mutex只有两种状态(lock & unlock)，而读写锁有三种状态读模式下加锁(所有以读模式对它进行加锁的线程都可以得到访问权，写模式访问则会被阻塞)，写模式加锁(所有试图访问的都会被阻塞)和无锁。
int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);
/* 如果希望读写锁有默认的属性，则分配一个NULL给attr */
int pthread_rwlock_destory(pthread_rwlock_t *rwlock);
int pthread_rwlock_rdlock(pthread_rwlock_t  *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t  *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t  *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t  *rwlock);
 
 
  1. /*作业请求作业*/ 
  2. #include <stdlib.h> 
  3. #include <pthread.h> 
  4.  
  5. struct job { 
  6.     struct job *j_next; 
  7.     struct job *j_prev; 
  8.     pthread_t j_id; 
  9.     /* something more */ 
  10. } 
  11.  
  12. struct queue { 
  13.     struct job *q_head; 
  14.     struct job *q_tail; 
  15.     pthread_rwlock_t q_lock; 
  16. }; 
  17.  
  18. /* 
  19.  *  Initialize a queue 
  20.  */ 
  21. int 
  22. queue_init(struct queue *qp) 
  23. { 
  24.     int err; 
  25.     qp->q_head = NULL; 
  26.     qp->q_tail = NULL; 
  27.     err = pthread_rwlock_init(&qp->q_lock, NULL); 
  28.     if (err != 0) 
  29.         return(err); 
  30.     return 0; 
  31. } 
  32.  
  33. /* 
  34.  *  Insert a job at the head of the queue 
  35.  */ 
  36. void 
  37. job_insert(struct queue *qp, struct job *jp) 
  38. { 
  39.     pthread_rwlock_wrlock(&qp->q_lock); 
  40.     jp->j_next = qp->q_head; 
  41.     jp->j_prev = NULL; 
  42.     if (qp->q_head != NULL) 
  43.         qp->q_head->j_prev = jp; 
  44.     else 
  45.         qp->q_tail->j_prev = jp; 
  46.     qp->q_head = jp; 
  47.     pthread_rwlock_unlock(&qp->q_lock); 
  48. } 
  49.      
  50. /* 
  51.  *  Append a job on the tail of the queue 
  52.  */ 
  53. void 
  54. job_append(struct queue *qp, struct job *jp) 
  55. { 
  56.     pthread_rwlock_wrlock(&qp->q_lock); 
  57.     jp->j_next = NULL; 
  58.     jp->j_prev = qp->q_tail; 
  59.  
  60.     if (qp->q_tail != NULL) 
  61.         qp->q_tail->q_next = jp; 
  62.     else 
  63.         qp->q_head = jp; 
  64.     qp->q_tail = jp; 
  65. } 
  66.  
  67. /* 
  68.  *  Remove the given job from a queue 
  69.  */ 
  70. void 
  71. job_remove(struct queue *qp, struct job *jp) 
  72. { 
  73.     pthread_rwlock_wrlock(qp->q_lock); 
  74.     if (qp->head == jp) {  
  75.         qp->head = jp->q_next; 
  76.         if (qp->tail == jp)  
  77.             qp->tail = NULL; 
  78.     } 
  79.     else if (qp->tail == jp)   
  80.             qp->tail = jp->q_prev;       
  81.     else { 
  82.         jp->q_prev->q->next = jp->q_next; 
  83.         jp->q_next->q->prev = jp->q_prev; 
  84.     } 
  85.     free(jp); 
  86.     pthread_rwlock_unlock(qp->lock); 
  87. } 
  88.  
  89. /* 
  90.  *  Find a job for the given thread ID 
  91.  */ 
  92. struct job * 
  93. job_find(struct queue *qp, pthread_t id) 
  94. { 
  95.     struct job *jp; 
  96.      
  97.     if (pthread_rwlock_rdlock(&qp->lock) != 0) 
  98.         return(NULL); 
  99.      
  100.     for (jp = qp->q_head; jp != NULL; jp = jp->j_next) 
  101.         if (pthread_equal(jp->j_id, id)) 
  102.             break; 
  103.     pthread_rwlock_unlock(&qp->lock)  
  104.     return jp; 
  105. } 
 
3. 条件变量
    条件变量是线程可用的另一种同步机制。通常和互斥量一起使用，允许线程以无竞争的方式等待特定条件发生。条件本身由互斥信号量保护，线程在改变条件状态之前必须首先锁住信号量，在获得信号量之前不会察觉到这种改变。
    条件变量在使用之前要初始化。动态分配的可以由pthread_cond_init函数来分配，静态变量可以直接将PTHREAD_COND_INITIALIZER赋给静态分配的条件。动态分配的变量需要使用pthread_mutex_destory来去初始化，然后再free。
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 strcut timespec *restrict timeout);
/*若成功则返回真，错误则返回错误编号*/
传递给pthread_cond_wait的互斥量对条件进行保护，调用者把锁住的信号量传给函数，函数把调用线程放到等待条件的线程列表上，然后对互斥量解锁。这个是原子操作，当它返回时，互斥量会被再次锁住。
pthread_cond_timedwait函数的工作方式与pthread_cond_wait函数相似。只是多了一个timeout。timeout变量指定了等待的时间。时间的结构：
struct timespec{
time_t tv_sec; /*seconds*/
long tv_nsec; /*nanoseconds*/
}
int pthread_cond_signal(pthread_cond_t *cond); /*唤醒等待该条件的某个进程*/
int pthread_cond_broadcast(pthread_cond_t *cond); /*唤醒等待该条件的所有进程*/
要注意的是，条件变量只是起阻塞和唤醒线程的作用，具体的判断条件还需用户给出，例如一个变量是否为0等等，这一点我们从后面的例子中可以看到。线程被唤醒后，它将重新检查判断条件是否满足，如果还不满足，一般说来线程应该仍阻塞在这里，被等待被下一次唤醒。这个过程一般用while语句实现。函数pthread_cond_broadcast（pthread_cond_t *cond）用来唤醒所有被阻塞在条件变量cond上的线程。这些线程被唤醒后将再次竞争相应的互斥锁，所以必须小心使用这个函数。
 
  1. pthread_mutex_t count_lock; 
  2. pthread_cond_t count_nonzero; 
  3. unsigned count; 
  4. decrement_count　() { 
  5.     pthread_mutex_lock (&count_lock); 
  6.     while(count == 0) 
  7.     pthread_cond_wait( &count_nonzero, &count_lock); 
  8.     count=count -1; 
  9.     pthread_mutex_unlock (&count_lock); 
  10. } 
  11.  
  12. increment_count(){ 
  13.     pthread_mutex_lock(&count_lock); 
  14.     if(count == 0) 
  15.         pthread_cond_signal(&count_nonzero); 
  16.     count=count+1; 
  17.     pthread_mutex_unlock(&count_lock); 
  18. } 
 
4. 信号量
信号量本质上是一个非负的整数计数器，它被用来控制对公共资源的访问。当公共资源增加时，调用函数sem_post（）增加信号量。只有当信号量值大于０时，才能使用公共资源，使用后，函数sem_wait（）减少信号量。函数sem_trywait（）和函数pthread_mutex_trylock（）起同样的作用，它是函数sem_wait（）的非阻塞版本。下面我们逐个介绍和信号量有关的一些函数，它们都在头文件/usr/include/semaphore.h中定义。
　　信号量的数据类型为结构sem_t，它本质上是一个长整型的数。函数sem_init（）用来初始化一个信号量。它的原型为：
　　extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
　　sem为指向信号量结构的一个指针；pshared不为０时此信号量在进程间共享，否则只能为当前进程的所有线程共享；value给出了信号量的初始值。
　　函数sem_post(sem_t *sem)用来增加信号量的值。当有线程阻塞在这个信号量上时，调用这个函数会使其中的一个线程唤醒，选择机制同样是由线程的调度策略决定的。
　　函数sem_wait( sem_t *sem)被用来阻塞当前线程直到信号量sem的值大于0，解除阻塞后将sem的值减一，表明公共资源经使用后减少。函数sem_trywait ( sem_t *sem)是函数sem_wait（）的非阻塞版本，它直接将信号量sem的值减一。
　　函数sem_destroy(sem_t *sem)用来释放信号量sem。
　　下面我们来看一个使用信号量的例子。在这个例子中，一共有4个线程，其中两个线程负责从文件读取数据到公共的缓冲区，另两个线程从缓冲区读取数据作不同的处理（加和乘运算）。
 
  1. /* File sem.c */ 
  2. #include <stdlib.h> 
  3. #include <pthread.h> 
  4. #include <semaphore.h> 
  5. #define MAXSTACK 100 
  6. int stack[MAXSTACK][2]; 
  7. int size=0; 
  8. sem_t sem; 
  9.  
  10. /* 
  11.  * 从文件1.dat读取数据，每读一次，信号量加1 
  12.  */ 
  13. void ReadData1(void) { 
  14.     FILE *fp=fopen("1.dat","r"); 
  15.     while(!feof(fp)){ 
  16.     fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]); 
  17.     sem_post(&sem); 
  18.     ++size; 
  19. } 
  20. fclose(fp); 
  21. } 
  22.  
  23. /* 
  24.  * 从文件2.dat读取数据 
  25.  */ 
  26. void ReadData2(void){ 
  27. FILE *fp=fopen("2.dat","r"); 
  28. while(!feof(fp)){ 
  29. fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]); 
  30. sem_post(&sem); 
  31. ++size; 
  32. } 
  33. fclose(fp); 
  34. } 
  35.  
  36. /* 
  37.  *阻塞等待缓冲区有数据，读取数据后，释放空间，继续等待 
  38.  */ 
  39. void HandleData1(void) { 
  40.     while(1){ 
  41.         sem_wait(&sem); 
  42.         printf("Plus:%d+%d=%dn",stack[size][0],stack[size][1], 
  43.         stack[size][0]+stack[size][1]); 
  44.         --size; 
  45.     } 
  46. } 
  47.  
  48. void 
  49. HandleData2(void) { 
  50.     while(1) { 
  51.         sem_wait(&sem); 
  52.         printf("Multiply:%d*%d=%dn",stack[size][0],stack[size][1], 
  53.         stack[size][0]*stack[size][1]); 
  54.         --size; 
  55.     } 
  56. } 
  57.  
  58. int 
  59. main(void) { 
  60.     pthread_t t1,t2,t3,t4; 
  61.     sem_init(&sem,0,0); 
  62.     pthread_create(&t1,NULL,(void *)HandleData1,NULL); 
  63.     pthread_create(&t2,NULL,(void *)HandleData2,NULL); 
  64.     pthread_create(&t3,NULL,(void *)ReadData1,NULL); 
  65.     pthread_create(&t4,NULL,(void *)ReadData2,NULL); 
  66.  
  67.     /* 防止程序过早退出，让它在此无限期等待*/ 
  68.     pthread_join(t1,NULL); 
  69. } 
　　在Linux下，我们用命令gcc -lpthread sem.c -o sem生成可执行文件sem。
我们事先编辑好数据文件1.dat和2.dat，假设它们的内容分别为1 2 3 4 5 6 7 8 9 10和 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10
，我们运行sem，得到如下的结果：
Multiply:-1*-2=2
Plus:-1+-2=-3
Multiply:9*10=90
Plus:-9+-10=-19
Multiply:-7*-8=56
Plus:-5+-6=-11
Multiply:-3*-4=12
Plus:9+10=19
Plus:7+8=15
Plus:5+6=11
 
　　从中我们可以看出各个线程间的竞争关系。而数值并未按我们原先的顺序显示出来这是由于size这个数值被各个线程任意修改的缘故。这也往往是多线程编程要注意的问题
 
Reference
APUE
互斥量，条件变量和信号量 http://blog.163.com/embeded-life/blog/static/10593251920098245319305/