四十二、Linux 线程——线程同步之条件变量之线程状态转换

42.1 线程状态转换

42.1.1 状态转换图

　　

42.1.2 一个线程计算，多个线程获取的案例

 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>
 
 /** 两个线程定义的共享资源 */
 typedef struct {
     int res;
     int counter;            ///< 用于统计获取结果线程的数量
     pthread_cond_t cond;    ///< 条件变量
     pthread_mutex_t mutex;  ///< 互斥锁
 }Result;
 
 /** 计算并将结果放置在 Result 中的线程运行函数 */
 void *set_fn(void *arg)
 {
     Result *r = (Result *)arg;
     int i = ;
     int sum = ;
 
     for(; i <= ; i++){
         sum += i;
     }
 
     /** 将结果放置到 Result 中 */
     r->res = sum;
 
     pthread_mutex_lock(&r->mutex);
     /** 判断获取结果的线程是否达到指定的数量 */
     while(r->counter < ){
         pthread_mutex_unlock(&r->mutex);
         usleep();
         pthread_mutex_lock(&r->mutex);
     }
     pthread_mutex_unlock(&r->mutex);
 
     /** 通知唤醒等待的那个获取结果的线程 */
     pthread_cond_broadcast(&r->cond);
 
     return (void *);
 }
 
 /** 获得结果的线程运行函数 */
 void *get_fn(void *arg)
 {
     Result *r = (Result *)arg;
 
     /** 对两个线程共享的判断条件进行保护（加锁） */
     /** 两个线程对判断条件的操作是互斥的 */
     pthread_mutex_lock(&r->mutex);
     /** 有一个线程准备好了，则计数器 +1 */
     r->counter++;
 
     /** 获取结果的线程等待 */
     pthread_cond_wait(&r->cond, &r->mutex);
 
     /** 被唤醒后 */
     pthread_mutex_unlock(&r->mutex);
 
     /** 去获取计算结果 */
     int res = r->res;
     printf("0x%lx get sum is %d\n", pthread_self(), res);
 
     return (void *);
 }
 
 int main(void)
 {
     int err;
     pthread_t cal, get1, get2;
 
     Result r;
     r.counter = ;
     pthread_cond_init(&r.cond, NULL);
     pthread_mutex_init(&r.mutex, NULL);
 
     /** 启动获取结果的线程 */
     if((err = pthread_create(&get1, NULL, get_fn, (void *)&r)) != ){
         perror("pthread create error");
     }
 
     if((err = pthread_create(&get2, NULL, get_fn, (void *)&r)) != ){
         perror("pthread create error");
     }
 
     /** 启动计算结果的线程 */
     if((err = pthread_create(&cal, NULL, set_fn, (void *)&r)) != ){
         perror("pthread create error");
     }
 
     pthread_join(cal, NULL);
     pthread_join(get1, NULL);
     pthread_join(get2, NULL);
 
     pthread_cond_destroy(&r.cond);
     pthread_mutex_destroy(&r.mutex);
 
     pthread_cond_destroy(&r.cond);
     pthread_mutex_destroy(&r.mutex);
     return ;
 }

　　编译运行结果如下：

　　

42.2 读者-写者案例

　　

• 几种情况：
  • 1 个写者，1 个读者
  • 1 个写者，多个读者
  • 多个写者，多个读者

　　完成第一种情况：

 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <string.h>
 #include <unistd.h>
 
 typedef struct {
     int             value;
 
     /** 读者 */
     pthread_cond_t  rc;
     pthread_mutex_t rm;
     int             r_wait;
 
     /** 写者 */
     pthread_cond_t  wc;
     pthread_mutex_t wm;
     int             w_wait;
 }Storage;
 
 /** 写入数据的函数 */
 void set_data(Storage *s, int value)
 {
     s->value = value;
 }
 
 /** 获取数据的函数 */
 int get_data(Storage *s)
 {
     return s->value;
 }
 
 /** 写者线程运行函数定义 */
 void *set_th(void *arg)
 {
     Storage *s = (Storage *)arg;
     int i = ;
     for(; i <= ; i++){
         /** 写入数据 */
         set_data(s, i +);
         printf("0x%lx(%-5d) write data : %d\n", pthread_self(), i, i + );
 
         pthread_mutex_lock(&s->rm);
         /** 判断读者线程是否准备好 */
         while(!s->r_wait){
             pthread_mutex_unlock(&s->rm);
             sleep();
             pthread_mutex_lock(&s->rm);
         }
         s->r_wait = ;
         pthread_mutex_unlock(&s->rm);
 
         /** 通知读者线程读取数据 */
         pthread_cond_broadcast(&s->rc);
 
         /** 写者线程自阻塞等待读者线程通知已经读取完毕,
          * 然后唤醒写者线程继续写入数据 */
         pthread_mutex_lock(&s->wm);
         s->w_wait = ;
         pthread_cond_wait(&s->wc, &s->wm);
         pthread_mutex_unlock(&s->wm);
 
     }
     return (void *);
 }
 
 /** 读者线程运行函数定义 */
 void *get_th(void *arg)
 {
     Storage *s = (Storage *)arg;
     int i = ;
     for(; i <= ; i++){
         pthread_mutex_lock(&s->rm);
         s->r_wait = ;
         pthread_cond_wait(&s->rc, &s->rm);
         pthread_mutex_unlock(&s->rm);
 
         /** 读者线程被唤醒后读取数据 */
         int value = get_data(s);
         printf("0x%lx(%-5d) read data: %d\n", pthread_self(), i, value);
 
         pthread_mutex_lock(&s->wm);
         /** 判断写者线程是否准备好 */
         while(!s->w_wait){
             pthread_mutex_unlock(&s->wm);
             sleep();
             pthread_mutex_lock(&s->wm);
         }
         /** 唤醒写者线程 */
         s->w_wait = ;
         pthread_mutex_unlock(&s->wm);
         pthread_cond_broadcast(&s->wc);
 
     }
     return (void *);
 }
 
 int main(void)
 {
     int err;
     pthread_t   rth, wth;
 
     Storage s;
     s.r_wait = ;
     s.w_wait = ;
     pthread_mutex_init(&s.rm, NULL);
     pthread_mutex_init(&s.wm, NULL);
     pthread_cond_init(&s.rc, NULL);
     pthread_cond_init(&s.wc, NULL);
 
     /** 创建一个读者线程和写者线程 */
     if((err = pthread_create(&rth, NULL, get_th, (void *)&s)) != ){
         perror("pthread create error");
     }
 
     if((err = pthread_create(&wth, NULL, set_th, (void *)&s)) != ){
         perror("pthread create error");
     }
 
     pthread_join(rth, NULL);
     pthread_join(wth, NULL);
 
     pthread_mutex_destroy(&s.rm);
     pthread_mutex_destroy(&s.wm);
     pthread_cond_destroy(&s.rc);
     pthread_cond_destroy(&s.wc);
 
     return ;
 }