进程同步



当某个线程可以修改变量，而其他线程也可以读取或者修改这个变量的时候，就需要对这些线程进行同步，以确保它们在访问变量的存储内容时，不会访问到无效的数据。

为了解决这个问题，线程使用锁，使得在同一个时间里，只允许一个进程访问变量。

1互斥量

互斥量从本质上说是一把锁，在访问共享资源前对互斥量进行加锁，在访问完成后释放互斥量上的锁。在互斥量进行加锁之后，任何其他试图再次对互斥量进行加锁的线程将会被阻塞知道当前线程释放该互斥锁。

#include <pthread.h>

互斥变量：pthread_mutex_t

静态互斥量的初始化：pthread_mutex_t mutex1=PTHREAD_MUTEX_INITIALIZER;

动态互斥量的初始化和销毁：

pthread_mutex_t mutex2;

pthread_mutex_init(&mutex2,NULL);

pthread_mutex_destroy(& mutex2);

开锁与解锁

if(0 != pthread_mutex_lock(&mutex2)){

perror("Pthread_mutex_lock error");

exit(1);

}

if(0 != pthread_mutex_trylock(&mutex2)){

perror("Pthread_mutex_trylock error");

exit(1);

}

if(0 != pthread_mutex_unlock(&mutex2)){

perror("Pthread_mutex_unlock error");

exit(1);

}

2读写锁

读写锁与互斥量类似，不过读写锁允许更高的并行性。读写锁可以有三种状态：读模式下加锁，写模式下加锁和不加锁状态。一次只有一个线程可以占用写模式锁，可以多个线程同时占用写模式锁。

当读写锁处于读模式锁定时，若有线程试图加写锁，读写锁会阻塞读模式锁的请求。

定义：pthread_rwlock_t rwmutex;

初始化：

if(0 != pthread_rwlock_init(&rwmutex,NULL)){

perror("Pthread_rwlock_init error");

exit(1);

}

注销：

if(0 != pthread_rwlock_destroy(&rwmutex)){

perror("Pthread_rwlock_destroy error");

exit(1);

}

加解锁：

if(0 != pthread_rwlock_rdlock(&rwmutex)){

perror("Pthread_rwlock_rdlock error");

exit(1);

}

 

if(0 != pthread_rwlock_wrlock(&rwmutex)){

perror("Pthread_rwlock_wrlock error");

exit(1);

}

 

if(0 != pthread_rwlock_unlock(&rwmutex)){

perror("Pthread_rwlock_unlock error");

exit(1);

}

3条件变量

条件变量与互斥量一起使用的时候，允许线程以无竞争的方式等待特定的条件发生。

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

定义：pthread_cond_t condmutex;

静态初始化：condmutex1=PTHREAD_COND_INITIALIZER;

动态初始化：

if(0 != pthread_cond_init(&condmutex2,NULL)){

perror("Pthread_cond_init error");

exit(1);

}

动态注销：

if(0 != pthread_cond_destroy(&condmutex2)){

perror("Pthread_cond_destroy error");

exit(1);

}

等待：

if(0 != pthread_cond_wait(condmutex2,mutex2)){

perror("Pthread_cond_wait error");

exit(1);

}

触发：

if(0 != pthread_cond_signal(&condmutex2)){

perror("Pthread_cond_signal error");

exit(1);

}

例子：

 #include <stdio.h>  

 #include <stdlib.h>  

 #include <unistd.h>  

 #include <string.h>  

 #include <pthread.h>  

 #include <semaphore.h>  

 /** 

 *int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t * cond_attr); 

 *int pthread_cond_signal(pthread_cond_t *cond); 

 *int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t * mutex); 

 *int pthread_cond_broadcast(pthread_cond_t *cond); 

 *int pthread_cond_timewait(pthread_cond_t *cond, pthread_mutex_t * mutex, const struct timespec * abstime); 

 *int pthread_cond_destroy(pthread_cond_t *cond); 

 */  

   

 void * pthread_odd_function(void * arg);  

 void * pthread_even_function(void * arg);  

 pthread_mutex_t work_mutex;  

 pthread_cond_t work_cond;  

   

 #define MAX_COUNT 10  

 int count = 0;  

   

 int main(int argc, char const *argv[])  

 {  

     pthread_t pthread_odd;  

     pthread_t pthread_even;  

     pthread_attr_t pthread_attr;  

 //  void * result;  

     int res;  

   

     res = pthread_attr_init(&pthread_attr);//init pthread attribute,step 1  

     if (res != 0)  

     {  

         perror("pthread_attr_init failed!");  

         exit(EXIT_FAILURE);  

     }  

   

     res = pthread_cond_init(&work_cond,NULL);  

     if (res != 0)  

     {  

         perror("pthread_cond_init failed!");  

         exit(EXIT_FAILURE);  

     }  

   

     res = pthread_mutex_init(&work_mutex,NULL);  

     if (res != 0)  

     {  

         perror("pthread_mutex_init failed!");  

         exit(EXIT_FAILURE);  

     }  

   

     pthread_attr_setdetachstate(&pthread_attr,PTHREAD_CREATE_DETACHED);//design pthread attribute step 2  

   

     res = pthread_create(&pthread_odd,&pthread_attr,pthread_odd_function,NULL);//step 3  

     if (res != 0)  

     {  

         perror("pthread_create failed!");  

         exit(EXIT_FAILURE);   

     }  

   

     res = pthread_create(&pthread_even,&pthread_attr,pthread_even_function,NULL);  

     if (res != 0)  

     {  

         perror("pthread_create failed!");  

         exit(EXIT_FAILURE);   

     }  

   

     while(count < MAX_COUNT);//wait the two sons threads finished   

     pthread_mutex_destroy(&work_mutex);  

     pthread_cond_destroy(&work_cond);  

     pthread_exit(NULL);  

     return 0;  

 }  

   

 void * pthread_odd_function(void *arg)//step 4  

 {  

     pthread_mutex_lock(&work_mutex);  

     while(count < MAX_COUNT)  

     {  

         if (count % 2 == 1)  

         {  

             ++count;  

             printf("the odd count is : %d\n", count);  

             pthread_cond_signal(&work_cond);//in order to release the thread of even  

         }  

         else  

             pthread_cond_wait(&work_cond,&work_mutex);//the pthread is blocked,wait for the condition  

     }  

     pthread_mutex_unlock(&work_mutex);  

 }  

   

   

 void * pthread_even_function(void *arg)//step 5  

 {  

     pthread_mutex_lock(&work_mutex);  

     while(count < MAX_COUNT)  

     {  

         if (count % 2 == 0)  

         {  

             ++count;  

             printf("the even count is : %d\n", count);  

             pthread_cond_signal(&work_cond);//in order to release the thread of odd  

         }  

         else  

             pthread_cond_wait(&work_cond,&work_mutex);//wait the condition satisfied  

     }  

     pthread_mutex_unlock(&work_mutex);  

 }  

实例转自：http://blog.csdn.net/hubi0952/article/details/8039604

运行结果为：