Linux 进程/线程同步机制

同步有三种方式：

互斥量  读写锁  条件变量 

信号量是另外一种同步方式（条件变量的升级版）

记录锁（文件锁）是读写锁的细分粒度

http://blog.csdn.net/xiajun07061225/article/details/8467853

http://www.cnblogs.com/sooner/p/3191931.html

下面是条件变量的实例，新建两个线程1和2，1使数字增加，2使数字减少，只有数字大于0时才可以减少，否则等待

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <pthread.h>

struct foo{
     int              f_count;
     pthread_mutex_t  f_mutex;
     pthread_cond_t   f_cond;
};

struct foo* foo_alloc(){
     struct foo* fp;
     fp = (struct foo*)malloc(sizeof(struct foo));
     if(fp != NULL){
        fp->f_count = 0;
	pthread_mutex_init(&fp->f_mutex,NULL);
	pthread_cond_init(&fp->f_cond,NULL);
     }
     return fp;
}

void foo_increase(struct foo* fp){
     pthread_mutex_lock(&fp->f_mutex);
     fp->f_count++;
     if(fp->f_count > 0){
        pthread_cond_signal(&fp->f_cond);
     }
     //fp->f_count++;
     pthread_mutex_unlock(&fp->f_mutex);
}

void foo_decrease(struct foo* fp){
     pthread_mutex_lock(&fp->f_mutex);
     while(fp->f_count == 0)
	     pthread_cond_wait(&fp->f_cond, &fp->f_mutex);
     fp->f_count --;
     pthread_mutex_unlock(&fp->f_mutex);
}

void* thread_func1(void* arg){
     struct foo* fp = (struct foo*)arg;
     printf("thread 1 start\n");
     foo_increase(fp);
     printf("in thread 1 count = %d\n",fp->f_count);
     printf("thread 1 exit\n");
     pthread_exit((void*)1);
}

void* thread_func2(void* arg){
     struct foo* fp = (struct foo*)arg;
     printf("thread 2 start\n");
     foo_decrease(fp);
     printf("in thread 2 count = %d\n",fp->f_count);
     printf("thread 2 exit\n");
     pthread_exit((void*)2);
}

int main(){
    pthread_t pid1,pid2;
    int err;
    void* pret;
    struct foo* fobj;
    fobj = foo_alloc();
    pthread_create(&pid1,NULL,thread_func1,(void*)fobj);
    pthread_create(&pid2,NULL,thread_func2,(void*)fobj);
    pthread_join(pid1,&pret);
    printf("thread 1 exit code is %d\n",(int)pret);
    pthread_join(pid2,&pret);
    printf("thread 2 exit code is %d\n",(int)pret);
}

运行结果

对结果的分析：

pthread_cond_signal(pthread_cond_t  *cond) 必须当条件改变时，才能给线程发送信号.

作用是:发送一个信号给另外一个正在处于阻塞等待状态的线程,使其脱离阻塞状态,继续执行.如果没有线程处在阻塞等待状态,pthread_cond_signal也会成功返回。

pthread_cond_wait(pthread_cond_t* restrict cond, pthread_mutex_t* restrict mutex)

该函数一进入wait状态就会自动release mutex。当其他线程通过pthread_cond_signal()或pthread_cond_broadcast，把该线程唤醒，使pthread_cond_wait()返回时，该线程又自动获得该mutex

该函数执行时，有两个原子操作，第一是解锁，第二挂起，使得该线程阻塞在等待队列中休眠

参考：http://blog.csdn.net/hudashi/article/details/7709421

//pthread_cond_signal 只发信号,内部不会解锁,在Linux线程中，有两个队列，分别是cond_wait队列和mutex_lock队列， cond_signal只是让线程从cond_wait队列移到mutex_lock队列，而不用返回到用户空间，不会有性能的损耗。(pthread_cond_signal 以及临界区 unlock后 pthread_cond_wait才能上锁)

//pthread_cond_wait 先解锁,等待,有信号来,上锁,   执行while检查防止另外的线程更改条件,至于为什么在被唤醒之后还要再次进行条件判断（即为什么要使用while循环来判断条件），是因为可能有“惊群效应”。有人觉得此处既然是被唤醒的，肯定是满足条件了，其实不然。如果是多个线程都在等待这个条件，而同时只能有一个线程进行处理，此时就必须要再次条件判断，以使只有一个线程进入临界区处理。

这是另外一种解释：http://blog.chinaunix.net/uid-11572501-id-3456343.html

又一个例子：线程1打印不是3的倍数，线程2打印3的倍数

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <pthread.h>

int i = 1;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  cond  = PTHREAD_COND_INITIALIZER;

void* thread_func1(void* arg){
        for(i = 1;i <= 9;i++){
        pthread_mutex_lock(&mutex);
	printf("call thread1\n");
	if(i%3 == 0){
	   pthread_cond_signal(&cond); 
	}
	else{
	   printf("thread1 %d\n",i);
	}
        pthread_mutex_unlock（&mutex);
	sleep(1);
      }
        printf("thread1 exit\n");
        pthread_exit((void*)1);
}

void* thread_func2(void* arg){
      while(i < 9){
        pthread_mutex_lock(&mutex);
    	printf("call thread2\n");
    	if(i%3 != 0){
    	   pthread_cond_wait(&cond,&mutex);
    	}
        printf("thread2 %d\n",i);
      	pthread_mutex_unlock(&mutex);
        sleep(1);
      } 
        printf("thread2 exit\n");
        pthread_exit((void*)2);
}

int  main(){
     pthread_t pid1,pid2;
     void* pret;
     pthread_create(&pid1,NULL,thread_func1,(void*)NULL);
     pthread_create(&pid2,NULL,thread_func2,(void*)NULL);
     pthread_join(pid1,&pret);
     printf("thread 1 exit code is %d\n",(int)pret);
     pthread_join(pid2,&pret);
     printf("thread 2 exit code is %d\n",(int)pret);
}

thread_func1  加入 sleep(1) 的用处:如果线程1先执行，且线程1锁住临界资源，线程2就因为无法获得临界资源一直阻塞，当执行if（i %3==0）时，没有因为这个条件而阻塞的线程...所以满足3的倍数的i无法打印.加入sleep(1)后，操作系统会把线程2调用

thread_func2  加入 sleep(1) 的用处: 打印完3的倍数后，应该由线程1继续执行，所以需要sleep(1)，由操作系统调度，使线程1开始运行.否则会重复不断打印3的倍数...直到操作系统调度线程1开始执行.