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

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

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

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

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

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

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

执行结果如下：

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

执行结果如下：

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

执行结果：

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

执行结果如下：

[cpp] view plaincopy
  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是否是偶数这个条件。

linux多线程编程——同步与互斥相关推荐

  1. Linux多线程编程---线程间同步（互斥锁、条件变量、信号量和读写锁）

    本篇博文转自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了 ...

  2. 多线程编程(3): 使用互斥锁同步线程

    python多线程编程(3): 使用互斥锁同步线程 问题的提出 上一节的例子中,每个线程互相独立,相互之间没有任何关系.现在假设这样一个例子:有一个全局的计数num,每个线程获取这个全局的计数,根据n ...

  3. Linux多线程编程-互斥锁

    互斥锁 多线程编程中,(多线程编程)可以用互斥锁(也称互斥量)可以用来保护关键代码段,以确保其独占式的访问,这有点像二进制信号量.POSIX互斥锁相关函数主要有以下5个: #include <p ...

  4. Linux多线程编程（不限Linux）

    --本文一个例子展开,介绍Linux下面线程的操作.多线程的同步和互斥. 前言 线程?为什么有了进程还需要线程呢,他们有什么区别?使用线程有什么优势呢?还有多线程编程的一些细节问题,如线程之间怎样同步 ...

  5. ZT 为什么pthread_cond_t要和pthread_mutex_t同时使用 || pthread/Linux多线程编程

    为什么线程同步的时候pthread_cond_t要和pthread_mutex_t同时使用 (2009-10-27 11:07:23) 转载▼ 标签: 杂谈 分类: 计算机 举一个例子(http:// ...

  6. linux查询某域线程是否满了,Linux多线程编程的时候怎么查看一个进程中的某个线程是否存活...

    pthread_kill: 别被名字吓到,pthread_kill可不是kill,而是向线程发送signal.还记得signal吗,大部分signal的默认动作是终止进程的运行,所以,我们才要用sig ...

  7. linux线程 ppt,Linux多线程编程多核编程.ppt

    <Linux多线程编程多核编程.ppt>由会员分享,可在线阅读,更多相关<Linux多线程编程多核编程.ppt(28页珍藏版)>请在装配图网上搜索. 1.Linux多线程编程, ...

  8. 多核程序设计 linux,多核程序设计Linux多线程编程.ppt

    Linux多线程编程,IEEE POSIX 标准 p1003.1c (Pthreads) 定义了处理线程的一系列C 语言类型的API. 在Linux中,线程一般被认为是"轻量级的进程&quo ...

  9. Linux 多线程编程（实现生产者消费者模型）

    Linux 多线程编程 线程分类 线程按照其调度者可以分为用户级线程和内核级线程两种. 内核级线程 在一个系统上实现线程模型的方式有好几种,因内核和用户空间提供的支持而有一定程度的级别差异.最简单的模 ...

最新文章

  1. poj 3660(Floyd求传递闭包)
  2. 使用MyEclipse的注解提示功能以及快捷键总结
  3. Linux图片的灰度化,iOS图像灰度解决方案--架构设计
  4. navicat10.1.7英文版_【纯干货】风险评估和管理（PDA TR 49内容节选11 中英文版）...
  5. python自动登录教程_Python 实现自动登录+点击+滑动验证功能
  6. JavaScript学习总结（12）——2016 年 7 个顶级 JavaScript 框架
  7. 九章基础算法02：栈和队列
  8. Spring之JDBC模板jdbcTemplate
  9. python找到二维数据矩阵中的最大最小值直接使用min、max函数
  10. baacloud苹果_Baacloud手机客户端下载
  11. 硬盘整数分区计算方法一般算法
  12. 统计推断——假设检验中 p 值的含义具体是什么？
  13. matlab subs的用法,Matlab subs函數的用法
  14. HTTP网络劫持的原理与过程、网站被劫持怎么办？
  15. Angular4中使用PrimeNG calendar
  16. 北大软件“软件成分分析与漏洞检测工具”（CoBOT—SCA）正式发布
  17. 加速度中的mg/LSB是什么意思
  18. BlockingQueue应用
  19. Zephyr UART
  20. qq2005beta1/2/3 cs 协议 release 1

热门文章

  1. java PKCS7Padding 加密Cannot find any provider supporting AES/CBC/PKCS7Padding 解决办法
  2. Mongodb Replica Configure
  3. Hello Views之Spinner（yaozq翻译，仅供参考）
  4. 11月中30个精心设计的网站案例精选
  5. 数据科学还是计算机科学_您应该拥有数据科学博客的3个原因
  6. bigquery数据类型_将BigQuery与TB数据一起使用后的成本和性能课程
  7. 个人项目api接口_5个免费有趣的API，可用于学习个人项目等
  8. leetcode 377. 组合总和 Ⅳ(dp)
  9. leetcode915. 分割数组
  10. javascript 符号_理解JavaScript中“ =”符号的直观指南