程序博客网 > 志鸿优化系列

linux多线程编程——同步与互斥

来源：互联网 发布：志鸿优化系列 编辑：程序博客网 时间：2024/05/22 08:00

一、 为什么要用多线程技术？

1、避免阻塞，大家知道，单个进程只有一个主线程，当主线程阻塞的时候，整个进程也就阻塞了，无法再去做其它的一些功能了。

2、避免CPU空转，应用程序经常会涉及到RPC，数据库访问，磁盘IO等操作，这些操作的速度比CPU慢很多，而在等待这些响应时，CPU却不能去处理新的请求，导致这种单线程的应用程序性能很差。

3、提升效率，一个进程要独立拥有4GB的虚拟地址空间，而多个线程可以共享同一地址空间，线程的切换比进程的切换要快得多。

二、  如何使用多线程技术进行编程？

下面给出个多线程程序，一个最简单的模拟售票系统，代码如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <pthread.h>  
  3.   
  4. void *ticketsell1(void *);  
  5. void *ticketsell2(void *);  
  6. int tickets = 20;  
  7.   
  8. int main()  
  9. {  
  10.     pthread_t id1,id2;  
  11.     int error;  
  12.   
  13.     error = pthread_create(&id1, NULL, ticketsell1, NULL);  
  14.     if(error != 0)  
  15.     {  
  16.         printf("pthread is not created!\n");  
  17.         return -1;  
  18.     }  
  19.   
  20.     error = pthread_create(&id2, NULL, ticketsell2, NULL);  
  21.     if(error != 0)  
  22.     {  
  23.         printf("pthread is not created!\n");  
  24.         return -1;  
  25.     }  
  26.   
  27.     pthread_join(id1,NULL);  
  28.     pthread_join(id2,NULL);  
  29.       
  30.     return 0;  
  31. }  
  32.   
  33. void *ticketsell1(void *arg)  
  34. {  
  35.     while(1)  
  36.     {  
  37.         if(tickets > 0)  
  38.         {  
  39. //          usleep(1000);  
  40.             printf("ticketse1 sells ticket:%d\n",tickets--);  
  41.         }  
  42.         else  
  43.         {  
  44.             break;  
  45.         }  
  46.     }  
  47.     return (void *)0;  
  48. }  
  49.   
  50. void *ticketsell2(void *arg)  
  51. {  
  52.     while(1)  
  53.     {  
  54.         if(tickets > 0)  
  55.         {  
  56. //          usleep(1000);  
  57.             printf("ticketse2 sells ticket:%d\n",tickets--);  
  58.         }  
  59.         else  
  60.         {  
  61.             break;  
  62.         }  
  63.     }  
  64.   
  65.     return (void *)0;  
  66. }  

执行结果如下：

[cpp] view plain copy
  1. fs@ubuntu:~/qiang/mthread$ ./mthread1   
  2. ticketse2 sells ticket:20  
  3. ticketse2 sells ticket:19  
  4. ticketse2 sells ticket:18  
  5. ticketse2 sells ticket:17  
  6. ticketse2 sells ticket:16  
  7. ticketse2 sells ticket:15  
  8. ticketse2 sells ticket:14  
  9. ticketse2 sells ticket:13  
  10. ticketse2 sells ticket:12  
  11. ticketse2 sells ticket:11  
  12. ticketse2 sells ticket:10  
  13. ticketse2 sells ticket:9  
  14. ticketse2 sells ticket:8  
  15. ticketse2 sells ticket:7  
  16. ticketse2 sells ticket:6  
  17. ticketse2 sells ticket:4  
  18. ticketse2 sells ticket:3  
  19. ticketse2 sells ticket:2  
  20. ticketse2 sells ticket:1  
  21. ticketse1 sells ticket:5  

看到结果，我们发现时能正常卖票的，一部分连续是sel2,另一部分是ticketsel1;

此时，其实存在一个隐含的问题，就是线程间的切换，在单CPU系统中，CPU是有时间片时间，时间片到了，就要执行其它的线程，假设thread1执行到if里面，但在printf执行前发生了线程切换，那么会发生什么呢？我们在这里用usleep函数(放开程序中的usleep注释行)进行强制模拟切换;

我们看看结果：

[cpp] view plain copy
  1. fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread  
  2. fs@ubuntu:~/qiang/mthread$ ./mthread1   
  3. ticketse2 sells ticket:20  
  4. ticketse1 sells ticket:19  
  5. ticketse2 sells ticket:18  
  6. ticketse1 sells ticket:17  
  7. ticketse2 sells ticket:16  
  8. ticketse1 sells ticket:15  
  9. ticketse2 sells ticket:14  
  10. ticketse1 sells ticket:13  
  11. ticketse2 sells ticket:12  
  12. ticketse1 sells ticket:11  
  13. ticketse2 sells ticket:10  
  14. ticketse1 sells ticket:9  
  15. ticketse2 sells ticket:8  
  16. ticketse1 sells ticket:7  
  17. ticketse2 sells ticket:6  
  18. ticketse1 sells ticket:5  
  19. ticketse2 sells ticket:4  
  20. ticketse1 sells ticket:3  
  21. ticketse1 sells ticket:2  
  22. ticketse2 sells ticket:1  
  23. ticketse1 sells ticket:0  
  24. fs@ubuntu:~/qiang/mthread$   

运行程序发现竟然有0号票被卖出了，这显然是错误的！当thread1的if里面发生线程切换时，thread2得到运行，把最后一张票卖了，此时thread1恢复运行，结果卖出了0号票，这里我们需要的是火车票的票数数据对于所有线程而言是同步的，所以就要用到线程同步技术了。

 

三、  使用多线程的同步与互斥

1、多线程的同步方式有很多种，例如互斥锁，条件变量，信号量，读写锁。先看看互斥锁如何解决多线程之间的同步问题。程序用互斥锁后如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <pthread.h>  
  3.   
  4. void *ticketsell1(void *);  
  5. void *ticketsell2(void *);  
  6. int tickets = 20;  
  7. pthread_mutex_t mutex;  
  8.   
  9. int main()  
  10. {  
  11.     pthread_t id1,id2;  
  12.     pthread_mutex_init(&mutex, NULL);//  
  13.     int error;  
  14.   
  15.     error = pthread_create(&id1, NULL, ticketsell1, NULL);  
  16.     if(error != 0)  
  17.     {  
  18.         printf("pthread is not created!\n");  
  19.         return -1;  
  20.     }  
  21.   
  22.     error = pthread_create(&id2, NULL, ticketsell2, NULL);  
  23.     if(error != 0)  
  24.     {  
  25.         printf("pthread is not created!\n");  
  26.         return -1;  
  27.     }  
  28.   
  29.     pthread_join(id1,NULL);  
  30.     pthread_join(id2,NULL);  
  31.       
  32.     return 0;  
  33. }  
  34.   
  35. void *ticketsell1(void *arg)  
  36. {  
  37.     while(1)  
  38.     {  
  39.         pthread_mutex_lock(&mutex);//给互斥量上锁  
  40.         if(tickets > 0)  
  41.         {  
  42.             usleep(1000);  
  43.             printf("ticketse1 sells ticket:%d\n",tickets--);  
  44.             pthread_mutex_unlock(&mutex);//给互斥量解锁  
  45.               
  46.         }  
  47.         else  
  48.         {  
  49.             pthread_mutex_unlock(&mutex);//给互斥量解锁  
  50.             break;  
  51.         }  
  52.         pthread_yield();//线程调度函数，使每个线程都有执行机会  
  53.     }  
  54.     return (void *)0;  
  55. }  
  56.   
  57. void *ticketsell2(void *arg)  
  58. {  
  59.     while(1)  
  60.     {  
  61.         pthread_mutex_lock(&mutex);//给互斥量上锁  
  62.         if(tickets > 0)  
  63.         {  
  64.             usleep(1000);  
  65.             printf("ticketse2 sells ticket:%d\n",tickets--);  
  66.             pthread_mutex_unlock(&mutex);//给互斥量解锁  
  67.         }  
  68.         else  
  69.         {  
  70.             pthread_mutex_unlock(&mutex);//给互斥量解锁  
  71.             break;  
  72.         }  
  73.         pthread_yield();//线程调度函数，是两个线程都有执行机会  
  74.     }  
  75.   
  76.     return (void *)0;  
  77. }  

执行结果如下：

[cpp] view plain copy
  1. fs@ubuntu:~/qiang/mthread$ vi mthread1.c  
  2. fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread  
  3. fs@ubuntu:~/qiang/mthread$ ./mthread1   
  4. ticketse2 sells ticket:20  
  5. ticketse1 sells ticket:19  
  6. ticketse2 sells ticket:18  
  7. ticketse1 sells ticket:17  
  8. ticketse2 sells ticket:16  
  9. ticketse1 sells ticket:15  
  10. ticketse2 sells ticket:14  
  11. ticketse1 sells ticket:13  
  12. ticketse2 sells ticket:12  
  13. ticketse1 sells ticket:11  
  14. ticketse2 sells ticket:10  
  15. ticketse1 sells ticket:9  
  16. ticketse2 sells ticket:8  
  17. ticketse1 sells ticket:7  
  18. ticketse2 sells ticket:6  
  19. ticketse1 sells ticket:5  
  20. ticketse2 sells ticket:4  
  21. ticketse1 sells ticket:3  
  22. ticketse2 sells ticket:2  
  23. ticketse1 sells ticket:1  


2、再看看用信号量来解决多线程的同步问题，程序代码如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <pthread.h>  
  3. #include <semaphore.h>  
  4.   
  5. void *ticketsell1(void *);  
  6. void *ticketsell2(void *);  
  7. int tickets = 20;  
  8. sem_t mutex,full;  
  9.   
  10. int main()  
  11. {  
  12.     pthread_t id1,id2;  
  13.     int error;  
  14.     int ret;  
  15.   
  16.     ret = sem_init(&mutex, 0 ,1);//初始化mutex信号量为1  
  17.     ret += sem_init(&full, 0 ,0);//初始化full信号量为0  
  18.   
  19.     if(ret != 0)  
  20.     {  
  21.         printf("sem_init fails!\n");  
  22.     }  
  23.   
  24.     error = pthread_create(&id1, NULL, ticketsell1, NULL);  
  25.     if(error != 0)  
  26.     {  
  27.         printf("pthread is not created!\n");  
  28.         return -1;  
  29.     }  
  30.   
  31.     error = pthread_create(&id2, NULL, ticketsell2, NULL);  
  32.     if(error != 0)  
  33.     {  
  34.         printf("pthread is not created!\n");  
  35.         return -1;  
  36.     }  
  37.   
  38.     pthread_join(id1,NULL);  
  39.     pthread_join(id2,NULL);  
  40.       
  41.     return 0;  
  42. }  
  43.   
  44. void *ticketsell1(void *arg)  
  45. {  
  46.     while(1)  
  47.     {  
  48.         sem_wait(&mutex);//mutex信号量进行P操作  
  49.         if(tickets > 0)  
  50.         {  
  51.             usleep(1000);  
  52.             printf("ticketse1 sells ticket:%d\n",tickets--);  
  53.             sem_post(&full);//full信号量进行V操作  
  54.         }  
  55.         else  
  56.         {  
  57.             sem_post(&full);//full信号量进行V操作  
  58.             break;  
  59.         }  
  60.     }  
  61.     return (void *)0;  
  62. }  
  63.   
  64. void *ticketsell2(void *arg)  
  65. {  
  66.     while(1)  
  67.     {  
  68.         sem_wait(&full);//full信号量进行P操作  
  69.         if(tickets > 0)  
  70.         {  
  71.             usleep(1000);  
  72.             printf("ticketse2 sells ticket:%d\n",tickets--);  
  73.             sem_post(&mutex);//mutex信号量进行V操作  
  74.         }  
  75.         else  
  76.         {  
  77.             sem_post(&mutex);//mutex信号量进行V操作  
  78.             break;  
  79.         }  
  80.     }  
  81.   
  82.     return (void *)0;  
  83. }  

执行结果：

[cpp] view plain copy
  1. fs@ubuntu:~/qiang/mthread$ vi mthread1.c  
  2. fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread  
  3. fs@ubuntu:~/qiang/mthread$ ./mthread1   
  4. ticketse1 sells ticket:20  
  5. ticketse2 sells ticket:19  
  6. ticketse1 sells ticket:18  
  7. ticketse2 sells ticket:17  
  8. ticketse1 sells ticket:16  
  9. ticketse2 sells ticket:15  
  10. ticketse1 sells ticket:14  
  11. ticketse2 sells ticket:13  
  12. ticketse1 sells ticket:12  
  13. ticketse2 sells ticket:11  
  14. ticketse1 sells ticket:10  
  15. ticketse2 sells ticket:9  
  16. ticketse1 sells ticket:8  
  17. ticketse2 sells ticket:7  
  18. ticketse1 sells ticket:6  
  19. ticketse2 sells ticket:5  
  20. ticketse1 sells ticket:4  
  21. ticketse2 sells ticket:3  
  22. ticketse1 sells ticket:2  
  23. ticketse2 sells ticket:1  
  24. fs@ubuntu:~/qiang/mthread$   

上面的sem_init函数用来初始化两个信号量的初始化值，这里一个设为1，一个设为0，sem_wait类似于P操作，让信号量减1，如果小于结果小于0，线程阻塞，否则线程继续执行，sem_post类似于V操作，提升信号量的值，加1，通过这两个信号量之间的互相“救对方”，就可以实现这两个线程的同步执行。

我们编译运行以上程序，发现两个售票点交替卖票，两个纯程依次得到机会执行，并且不会有0号票卖出，实现了同步。

 

3、我们再用条件变量来解决同步问题，一般条件变量需要结合互斥量一起使用，代码如下

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <pthread.h>  
  3. #include <semaphore.h>  
  4.   
  5. void *ticketsell1(void *);  
  6. void *ticketsell2(void *);  
  7. int tickets = 20;  
  8. pthread_mutex_t mutex;  
  9. pthread_cond_t  qready = PTHREAD_COND_INITIALIZER;//静态初始化条件变量;  
  10.           
  11. int main()  
  12. {  
  13.     pthread_t id1,id2;  
  14.     pthread_mutex_init(&mutex, NULL);  
  15.     int error;  
  16.   
  17.     error = pthread_create(&id1, NULL, ticketsell1, NULL);  
  18.     if(error != 0)  
  19.     {  
  20.         printf("pthread is not created!\n");  
  21.         return -1;  
  22.     }  
  23.   
  24.     error = pthread_create(&id2, NULL, ticketsell2, NULL);  
  25.     if(error != 0)  
  26.     {  
  27.         printf("pthread is not created!\n");  
  28.         return -1;  
  29.     }  
  30.   
  31.     pthread_join(id1,NULL);  
  32.     pthread_join(id2,NULL);  
  33.       
  34.     return 0;  
  35. }  
  36.   
  37. void *ticketsell1(void *arg)  
  38. {  
  39.     pthread_mutex_lock(&mutex);  
  40.     while(tickets > 0)  
  41.     {  
  42.         if(tickets%2 == 1)  
  43.         {  
  44.             usleep(1000);  
  45.             printf("ticketse1 sells ticket:%d\n",tickets--);  
  46.             pthread_cond_signal(&qready);//条件改变，发送信号，通知ticketse2  
  47.         }  
  48.         else  
  49.         {  
  50.             pthread_cond_wait(&qready,&mutex);//解开Mutex,并等待qready改变  
  51.         }  
  52.         pthread_mutex_unlock(&mutex);//给互斥量解锁  
  53.     }  
  54.     return (void *)0;  
  55. }  
  56.   
  57. void *ticketsell2(void *arg)  
  58. {  
  59.     pthread_mutex_lock(&mutex);  
  60.     while(tickets > 0)  
  61.     {  
  62.         if(tickets%2 == 0)  
  63.         {  
  64.             usleep(1000);  
  65.             printf("ticketse2 sells ticket:%d\n",tickets--);  
  66.             pthread_cond_signal(&qready);//条件改变，发送信号，通知ticketse1  
  67.         }  
  68.         else  
  69.         {  
  70.             pthread_cond_wait(&qready,&mutex);//解开mutex,并等待qready改变  
  71.         }  
  72.         pthread_mutex_unlock(&mutex);//给互斥量解锁  
  73.     }  
  74.   
  75.     return (void *)0;  
  76. }  

执行结果如下：

[cpp] view plain copy
  1. fs@ubuntu:~/qiang/mthread$ vi mthread1.c  
  2. fs@ubuntu:~/qiang/mthread$ gcc -o mthread1 mthread1.c -lpthread  
  3. fs@ubuntu:~/qiang/mthread$ ./mthread1   
  4. ticketse2 sells ticket:20  
  5. ticketse1 sells ticket:19  
  6. ticketse2 sells ticket:18  
  7. ticketse1 sells ticket:17  
  8. ticketse2 sells ticket:16  
  9. ticketse1 sells ticket:15  
  10. ticketse2 sells ticket:14  
  11. ticketse1 sells ticket:13  
  12. ticketse2 sells ticket:12  
  13. ticketse1 sells ticket:11  
  14. ticketse2 sells ticket:10  
  15. ticketse1 sells ticket:9  
  16. ticketse2 sells ticket:8  
  17. ticketse1 sells ticket:7  
  18. ticketse2 sells ticket:6  
  19. ticketse1 sells ticket:5  
  20. ticketse2 sells ticket:4  
  21. ticketse1 sells ticket:3  
  22. ticketse2 sells ticket:2  
  23. ticketse1 sells ticket:1  
  24. fs@ubuntu:~/qiang/mthread$   


  条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件变量发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线程间的同步.

函数pthread_cond_wait使线程阻塞在一个条件变量上,而函数pthread_cond_signal是用来释放被阻塞在条件变量上的一个线程。但是要注意的是，条件变量只是起到阻塞和唤醒线程的作用，具体的判断条件还需用户给出，我这里给出的是tickets是否是偶数这个条件。

0 0
志鸿优化系列 志鸿优化系列
原创粉丝点击
热门IT博客
c语言中mod是表示什么c语言中mod是表示什么
淘宝健身教练靠谱吗淘宝健身教练靠谱吗
行政审批软件用户手册
云计算与大数据专业
双机软件品牌
迅雷网游加速器 mac
拳霸摇杆知乎
姚明赛季数据
java中高并发解决方案
剧本下载软件
pi数据库安装包下载
pc蛋蛋预测软件
网校源码
catdrawing转换cad软件
非诚勿扰淘宝男被灭灯
足浴软件
网站域名未授权
命令行查看数据库内容
怎么缩小毛孔知乎
看电影啥软件好?
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 扣扣号被收回了怎么办 大便不易冲怎么办 快手没微信登录怎么办 win7账户锁定怎么办 玩dota卡怎么办 网赌被骗怎么办 镀晶完遇下雨怎么办 微信发信息英文怎么办 身体很虚弱怎么办 东西没了怎么办 怎么办白话怎么说 喝醉酒爱耍酒疯怎么办 鼻子过度通气怎么办 鱼看着没精神怎么办 裸脸皮肤很干怎么办 闭合性粉刺怎么办 护肤霜过敏怎么办 化妆品过敏红肿怎么办 痘痘肌出汗了怎么办 敷面膜刺激怎么办 皮肤遇热就红怎么办 脸上闭口粉刺怎么办 晒伤怎么办 祛斑霜脱皮怎么办 雪肌精过敏怎么办 脸上长痘硬包怎么办 打鱼输钱怎么办 汽车白漆变黄怎么办 白色美缝剂变黄怎么办 白色美缝剂发黄怎么办 大富翁坐牢怎么办 小区天天停水怎么办 iphone下载慢怎么办 iponex下载慢怎么办 苹果下载慢怎么办 vivox9网络不好怎么办 达飞云贷倒闭了怎么办 vivox5l手机卡怎么办 vivo手机手机卡怎么办 vivox6充电慢怎么办 vivo充电慢怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里