资讯专栏INFORMATION COLUMN

理解线程2 信号量和互斥量 理解线程同步

Honwhy / 2457人阅读

摘要:线程同步了解线程信号量的基础知识,对深入理解的线程会大有帮助。当两个线程同时执行时,不可避免同时操作同一个变量或者文件等,所以需要有一组机制来确保他们能正确的运行信号量和互斥量。

线程同步

了解线程信号量的基础知识,对深入理解python的线程会大有帮助。

当两个线程同时执行时,不可避免同时操作同一个变量或者文件等,所以需要有一组机制来确保他们能正确的运行:信号量和互斥量。信号量可以分为最简单的“二进制信号量”和更通用的“计数信号量”。信号量通常用来保护一段代码,使其每次只能被一个执行线程运行,这种情况下需要用到二进制信号量。有时候希望可以允许有限数目的线程执行一段指定代码,这就需要用到计数信号量。实际上,技术信号量是一种二进制信号量的逻辑扩展,实际两者调用的函数一样。

互斥量和信号量很相似,事实上他们可以互相通过对方来实现。但在实际应用中,对于一些情况使用其中一种更符合语义而且效果更好。

用信号量进行同步

</>复制代码

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. void *thread_function(void *arg);
  8. sem_t bin_sem;
  9. #define WORK_SIZE 1024
  10. char work_area[WORK_SIZE]; /* 用来存放输入内容 */
  11. int main() {
  12. int res; /* 暂存一些命令的返回结果 */
  13. pthread_t a_thread; /* 织带新建的线程 */
  14. void *thread_result; /* 存放线程处理结果 */
  15. res = sem_init(&bin_sem, 0, 0); /* 初始化信号量,并且设置初始值为0*/
  16. if (res != 0) {
  17. perror("Semaphore initialization failed");
  18. exit(EXIT_FAILURE);
  19. }
  20. res = pthread_create(&a_thread, NULL, thread_function, NULL); /* 创建新线程 */
  21. if (res != 0) {
  22. perror("Thread creation failed");
  23. exit(EXIT_FAILURE);
  24. }
  25. printf("Inout some text, Enter "end" to finish
  26. ");
  27. while(strncmp("end", work_area, 3) != 0) { /* 当工作区内不是以end开头的字符串时...*/
  28. fgets(work_area, WORK_SIZE, stdin); /* 从标准输入获取输入到worl_area */
  29. sem_post(&bin_sem); /* 信号量+1 */
  30. }
  31. printf("
  32. Waiting for thread to finish...
  33. ");
  34. res = pthread_join(a_thread, &thread_result); /* 等待线程结束 */
  35. if (res != 0) {
  36. perror("Thread join failed");
  37. exit(EXIT_FAILURE);
  38. }
  39. printf("Thread joined
  40. ");
  41. sem_destroy(&bin_sem); /* 销毁信号量 */
  42. exit(EXIT_SUCCESS);
  43. }
  44. void *thread_function(void *arg) {
  45. sem_wait(&bin_sem); /* 等待信号量有大于0的值然后-1 */
  46. while(strncmp("end", work_area, 3) != 0) {
  47. printf("You input %ld characters
  48. ", strlen(work_area)-1); /* 获取输入字符串长度 8*/
  49. sem_wait(&bin_sem); /* 等待信号量有大于0的值然后-1 */
  50. }
  51. pthread_exit(NULL);
  52. }
用互斥量进行同步

</>复制代码

  1. #include
  2. #include
  3. #include
  4. #include
  5. #include
  6. #include
  7. void *thread_function(void *arg);
  8. pthread_mutex_t work_mutex;
  9. #define WORK_SIZE 1024
  10. char work_area[WORK_SIZE];
  11. int time_to_exit = 0; /* 用来控制TODO*/
  12. int main() {
  13. int res;
  14. pthread_t a_thread;
  15. void *thread_result;
  16. res = pthread_mutex_init(&work_mutex,NULL); /* 初始化一个互斥锁 */
  17. if (res != 0) {
  18. perror("Mutex initialization failed");
  19. exit(EXIT_FAILURE);
  20. }
  21. res = pthread_create(&a_thread, NULL, thread_function, NULL); /* 创建一个新线程 */
  22. if (res != 0) {
  23. perror("Thread creation failed");
  24. exit(EXIT_FAILURE);
  25. }
  26. pthread_mutex_lock(&work_mutex); /* 尝试对互斥量加锁 */
  27. printf("Input some text, Enter "end" to finish
  28. ");
  29. while(!time_to_exit) { /* 检查是不是该退出*/
  30. fgets(work_area, WORK_SIZE, stdin); /* 从标准输入获取输入到work_area */
  31. pthread_mutex_unlock(&work_mutex); /* 解锁互斥量 */
  32. while(1) {
  33. pthread_mutex_lock(&work_mutex);
  34. if (work_area[0] != "") { /* 持续检查work_area 是否为空, 如果不为空继续等待,如果为空,则重新读取输入到work_area*/
  35. pthread_mutex_unlock(&work_mutex);
  36. sleep(1);
  37. }
  38. else {
  39. break;
  40. }
  41. }
  42. }
  43. pthread_mutex_unlock(&work_mutex);
  44. printf("
  45. Waiting for thread to finish...
  46. ");
  47. res = pthread_join(a_thread, &thread_result);
  48. if (res != 0) {
  49. perror("Thread join failed");
  50. exit(EXIT_FAILURE);
  51. }
  52. printf("Thread joined
  53. ");
  54. pthread_mutex_destroy(&work_mutex);
  55. exit(EXIT_SUCCESS);
  56. }
  57. void *thread_function(void *arg) {
  58. sleep(1);
  59. pthread_mutex_lock(&work_mutex); /* 尝试加锁互斥量 */
  60. while(strncmp("end", work_area, 3) != 0) { /* 当work_area里的值不是以end开头时*/
  61. printf("You input %ld characters
  62. ", strlen(work_area) -1); /* 输出输入的字符长度 */
  63. work_area[0] = ""; /* work_area设置为空 */
  64. pthread_mutex_unlock(&work_mutex);
  65. sleep(1);
  66. pthread_mutex_lock(&work_mutex);
  67. while (work_area[0] == "") { /* 持续检查work_area 直到它里面有输入值*/
  68. pthread_mutex_unlock(&work_mutex);
  69. sleep(1);
  70. pthread_mutex_lock(&work_mutex);
  71. }
  72. }
  73. time_to_exit = 1; /* 当输入end后,设置退出标志 */
  74. work_area[0] = "";
  75. pthread_mutex_unlock(&work_mutex);
  76. pthread_exit(0);
  77. }
参考资料

《Beginning Linux Programming》

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/44279.html

相关文章

  • 线程安全

    摘要:不可变在中,不可变的对象一定是线程安全的。在里标注自己是线程安全的类,大多都不是绝对线程安全,比如某些情况下类在调用端也需要额外的同步措施。无同步方案要保证线程安全,不一定就得需要数据的同步,两者没有因果关系。 在之前学习编程的时候,有一个概念根深蒂固,即程序=算法+数据结构。数据代表问题空间中的客体,代码就用来处理这些数据,这种思维是站在计算机的角度去抽象问题和解决问题,称之为面向过...

    fuyi501 评论0 收藏0
  • Java 并发学习笔记

    摘要:方法可以将当前线程放入等待集合中,并释放当前线程持有的锁。此后,该线程不会接收到的调度,并进入休眠状态。该线程会唤醒,并尝试恢复之前的状态。 并发 最近重新复习了一边并发的知识,发现自己之前对于并发的了解只是皮毛。这里总结以下Java并发需要掌握的点。 使用并发的一个重要原因是提高执行效率。由于I/O等情况阻塞,单个任务并不能充分利用CPU时间。所以在单处理器的机器上也应该使用并发。为...

    DrizzleX 评论0 收藏0
  • 并发编程导论

    摘要:并发编程导论是对于分布式计算并发编程系列的总结与归纳。并发编程导论随着硬件性能的迅猛发展与大数据时代的来临,并发编程日益成为编程中不可忽略的重要组成部分。并发编程复兴的主要驱动力来自于所谓的多核危机。 并发编程导论是对于分布式计算-并发编程 https://url.wx-coder.cn/Yagu8 系列的总结与归纳。欢迎关注公众号:某熊的技术之路。 showImg(https://...

    GeekQiaQia 评论0 收藏0
  • Java多线程笔记(零):进程、线程与通用概念

    摘要:父进程调用创建子进程。因而,一个进程的第一个线程会随着这个进程的启动而创建,这个线程被称为该进程的主线程。另一方面,线程不可能独立于进程存在。终止线程线程可以通过多种方式来终结同一个进程中的其他线程。 前言 不积跬步,无以至千里;不积小流,无以成江海。在学习Java多线程相关的知识前,我们首先需要去了解一点操作系统的进程、线程以及相关的基础概念。 进程 通常,我们把一个程序的执行称为一...

    blastz 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<