首页 > 系统教程

线程同步的方法有哪些？Linux下实现线程同步的三种方法

番茄系统家园 · 2023-02-07 00:30:17

线程同步的方法有哪些？ 在linux下，系统提供了很多种方式来实现线程同步，其中最常用的便是互斥锁、条件变量和信号量这三种方式，可能还有很多伙伴对于这三种方法都不熟悉，下面就给大家详细介绍下。

线程同步的方法有哪些？Linux下实现线程同步的三种方法

Linux下实现线程同步的三种方法：

一、互斥锁（mutex）

通过锁机制实现线程间的同步。

1、初始化锁。在Linux下，线程的互斥量数据类型是pthread_mutex_t。在使用前，要对它进行初始化。

静态分配：pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER；

动态分配：int pthread_mutex_init（pthread_mutex_t mutex， const pthread_mutex_attr_t mutexattr）；

2、加锁。对共享资源的访问，要对互斥量进行加锁，如果互斥量已经上了锁，调用线程会阻塞，直到互斥量被解锁。

int pthread_mutex_lock（pthread_mutex *mutex）；

int pthread_mutex_trylock（pthread_mutex_t *mutex）；

3、解锁。在完成了对共享资源的访问后，要对互斥量进行解锁。

int pthread_mutex_unlock（pthread_mutex_t *mutex）；

4、销毁锁。锁在是使用完成后，需要进行销毁以释放资源。

int pthread_mutex_destroy（pthread_mutex *mutex）；

  1. 01 #include
  2. 02 #include
  3. 03 #include
  4. 04 #include
  5. 05 #include "iostream"
  6. 06 using namespace std;
  7. 07 pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  8. 08 int tmp;
  9. 09 void thread(void arg)
  10. 10 {
  11. 11 cout
  12. 12 pthread_mutex_lock(&mutex);
  13. 13 tmp = 12;
  14. 14 cout
  15. 15 pthread_mutex_unlock(&mutex);
  16. 16 return NULL;
  17. 17 }
  18. 18 int main()
  19. 19 {
  20. 20 pthread_t id;
  21. 21 cout
  22. 22 tmp = 3;
  23. 23 cout
  24. 24 if (!pthread_create(&id, NULL, thread, NULL))
  25. 25 {
  26. 26 cout
  27. 27 }
  28. 28 else
  29. 29 {
  30. 30 cout
  31. 31 }
  32. 32 pthread_join(id, NULL);
  33. 33 pthread_mutex_destroy(&mutex);
  34. 34 return 0;
  35. 35 }
  36. 36 //编译：g++ -o thread testthread.cpp -lpthread

复制代码

include #include #include #include

include "iostream" using namespace std; pthread_mutex_t mutex =

PTHREAD_MUTEX_INITIALIZER; int tmp; void thread(void arg) { cout

二、条件变量（cond）

与互斥锁不同，条件变量是用来等待而不是用来上锁的。条件变量用来自动阻塞一个线程，直到某特殊情况发生为止。通常条件变量和互斥锁同时使用。条件变量分为两部分： 条件和变量。条件本身是由互斥量保护的。线程在改变条件状态前先要锁住互斥量。条件变量使我们可以睡眠等待某种条件出现。条件变量是利用线程间共享的全局变量进行同步的一种机制，主要包括两个动作：一个线程等待“条件变量的条件成立”而挂起；另一个线程使“条件成立”（给出条件成立信号）。条件的检测是在互斥锁的保护下进行的。如果一个条件为假，一个线程自动阻塞，并释放等待状态改变的互斥锁。如果另一个线程改变了条件，它发信号给关联的条件变量，唤醒一个或多个等待它的线程，重新获得互斥锁，重新评价条件。如果两进程共享可读写的内存，条件变量可以被用来实现这两进程间的线程同步。

1、初始化条件变量。

静态态初始化，pthread_cond_t cond = PTHREAD_COND_INITIALIER；

动态初始化，int pthread_cond_init（pthread_cond_t cond， pthread_condattr_t cond_attr）；

2、等待条件成立。释放锁，同时阻塞等待条件变量为真才行。timewait（）设置等待时间，仍未signal，返回ETIMEOUT（加锁保证只有一个线程wait）

int pthread_cond_wait（pthread_cond_t cond， pthread_mutex_t mutex）；

int pthread_cond_timewait（pthread_cond_t cond，pthread_mutex mutex，const timespec *abstime）；

4、激活条件变量。pthread_cond_signal，pthread_cond_broadcast（激活所有等待线程）

int pthread_cond_signal（pthread_cond_t *cond）；

int pthread_cond_broadcast（pthread_cond_t *cond）; //解除所有线程的阻塞

5、清除条件变量。无线程等待，否则返回EBUSY

int pthread_cond_destroy（pthread_cond_t *cond）；

  1. 01 [cpp] view plain copy
  2. 02 #include
  3. 03 #include
  4. 04 #include "stdlib.h"
  5. 05 #include "unistd.h"
  6. 06 pthread_mutex_t mutex;
  7. 07 pthread_cond_t cond;
  8. 08 void hander(void *arg)
  9. 09 {
  10. 10 free(arg);
  11. 11 (void)pthread_mutex_unlock(&mutex);
  12. 12 }
  13. 13 void thread1(void arg)
  14. 14 {
  15. 15 pthread_cleanup_push(hander, &mutex);
  16. 16 while(1)
  17. 17 {
  18. 18 printf("thread1 is running");
  19. 19 pthread_mutex_lock(&mutex);
  20. 20 pthread_cond_wait(&cond, &mutex);
  21. 21 printf("thread1 applied the condition");
  22. 22 pthread_mutex_unlock(&mutex);
  23. 23 sleep(4);
  24. 24 }
  25. 25 pthread_cleanup_pop(0);
  26. 26 }
  27. 27 void thread2(void arg)
  28. 28 {
  29. 29 while(1)
  30. 30 {
  31. 31 printf("thread2 is running");
  32. 32 pthread_mutex_lock(&mutex);
  33. 33 pthread_cond_wait(&cond, &mutex);
  34. 34 printf("thread2 applied the condition");
  35. 35 pthread_mutex_unlock(&mutex);
  36. 36 sleep(1);
  37. 37 }
  38. 38 }
  39. 39 int main()
  40. 40 {
  41. 41 pthread_t thid1,thid2;
  42. 42 printf("condition variable study!");
  43. 43 pthread_mutex_init(&mutex, NULL);
  44. 44 pthread_cond_init(&cond, NULL);
  45. 45 pthread_create(&thid1, NULL, thread1, NULL);
  46. 46 pthread_create(&thid2, NULL, thread2, NULL);
  47. 47 sleep(1);
  48. 48 do
  49. 49 {
  50. 50 pthread_cond_signal(&cond);
  51. 51 }while(1);
  52. 52 sleep(20);
  53. 53 pthread_exit(0);
  54. 54 return 0;
  55. 55 }

复制代码

[cpp] view plain copy #include #include #include "stdlib.h" #include "unistd.h" pthread_mutex_t mutex; pthread_cond_t cond; void hander(void arg) { free(arg); (void)pthread_mutex_unlock(&mutex); } void thread1(void arg) { pthread_cleanup_push(hander, &mutex); while(1) { printf("thread1 is running"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread1 applied the condition"); pthread_mutex_unlock(&mutex); sleep(4); } pthread_cleanup_pop(0); } void thread2(void *arg) { while(1) { printf("thread2 is running"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread2 applied the condition"); pthread_mutex_unlock(&mutex); sleep(1); } } int main() { pthread_t thid1,thid2; printf("condition variable study!"); pthread_mutex_init(&mutex, NULL); pthread_cond_init(&cond, NULL); pthread_create(&thid1, NULL, thread1, NULL); pthread_create(&thid2, NULL, thread2, NULL); sleep(1); do { pthread_cond_signal(&cond); }while(1); sleep(20); pthread_exit(0); return 0; }

  1. 01 #include
  2. 02 #include
  3. 03 #include "stdio.h"
  4. 04 #include "stdlib.h"
  5. 05 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
  6. 06 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  7. 07 struct node
  8. 08 {
  9. 09 int n_number;
  10. 10 struct node *n_next;
  11. 11 }*head = NULL;
  12. 12 static void cleanup_handler(void *arg)
  13. 13 {
  14. 14 printf("Cleanup handler of second thread./n");
  15. 15 free(arg);
  16. 16 (void)pthread_mutex_unlock(&mtx);
  17. 17 }
  18. 18 static void thread_func(void arg)
  19. 19 {
  20. 20 struct node *p = NULL;
  21. 21 pthread_cleanup_push(cleanup_handler, p);
  22. 22 while (1)
  23. 23 {
  24. 24 //这个mutex主要是用来保证pthread_cond_wait的并发性
  25. 25 pthread_mutex_lock(&mtx);
  26. 26 while (head == NULL)
  27. 27 {
  28. 28 //这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何
  29. 29 //这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线
  30. 30 //程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。
  31. 31 //这个时候，应该让线程继续进入pthread_cond_wait
  32. 32 // pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，
  33. 33 //然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立
  34. 34 //而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源
  35. 35 //用这个流程是比较清楚的
  36. 36 pthread_cond_wait(&cond, &mtx);
  37. 37 p = head;
  38. 38 head = head->n_next;
  39. 39 printf("Got %d from front of queue/n", p->n_number);
  40. 40 free(p);
  41. 41 }
  42. 42 pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁
  43. 43 }
  44. 44 pthread_cleanup_pop(0);
  45. 45 return 0;
  46. 46 }
  47. 47 int main(void)
  48. 48 {
  49. 49 pthread_t tid;
  50. 50 int i;
  51. 51 struct node *p;
  52. 52 //子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而
  53. 53 //不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大
  54. 54 pthread_create(&tid, NULL, thread_func, NULL);
  55. 55 sleep(1);
  56. 56 for (i = 0; i
  57. 57 {
  58. 58 p = (struct node*)malloc(sizeof(struct node));
  59. 59 p->n_number = i;
  60. 60 pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁，
  61. 61 p->n_next = head;
  62. 62 head = p;
  63. 63 pthread_cond_signal(&cond);
  64. 64 pthread_mutex_unlock(&mtx); //解锁
  65. 65 sleep(1);
  66. 66 }
  67. 67 printf("thread 1 wanna end the line.So cancel thread 2./n");
  68. 68 //关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出
  69. 69 //线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。
  70. 70 pthread_cancel(tid);
  71. 71 pthread_join(tid, NULL);
  72. 72 printf("All done -- exiting/n");
  73. 73 return 0;
  74. 74 }

复制代码

include #include #include "stdio.h" #include

"stdlib.h" static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER; static pthread_cond_t cond = PTHREAD_COND_INITIALIZER; struct node { int n_number; struct node n_next; }head = NULL; static void cleanup_handler(void arg) { printf("Cleanup handler of second thread./n"); free(arg); (void)pthread_mutex_unlock(&mtx); } static void thread_func(void arg) { struct node p = NULL; pthread_cleanup_push(cleanup_handler, p); while (1) { //这个mutex主要是用来保证pthread_cond_wait的并发性 pthread_mutex_lock(&mtx); while (head == NULL) { //这个while要特别说明一下，单个pthread_cond_wait功能很完善，为何 //这里要有一个while (head == NULL)呢？因为pthread_cond_wait里的线 //程可能会被意外唤醒，如果这个时候head != NULL，则不是我们想要的情况。 //这个时候，应该让线程继续进入pthread_cond_wait // pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx， //然后阻塞在等待对列里休眠，直到再次被唤醒(大多数情况下是等待的条件成立 //而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源 //用这个流程是比较清楚的 pthread_cond_wait(&cond, &mtx); p = head; head = head->n_next; printf("Got %d from front of queue/n", p->n_number); free(p); } pthread_mutex_unlock(&mtx); //临界区数据操作完毕，释放互斥锁 } pthread_cleanup_pop(0); return 0; } int main(void) { pthread_t tid; int i; struct node p; //子线程会一直等待资源，类似生产者和消费者，但是这里的消费者可以是多个消费者，而 //不仅仅支持普通的单个消费者，这个模型虽然简单，但是很强大 pthread_create(&tid, NULL, thread_func, NULL); sleep(1); for (i = 0; i )malloc(sizeof(struct node)); p->n_number = i; pthread_mutex_lock(&mtx); //需要操作head这个临界资源，先加锁， p->n_next = head; head = p; pthread_cond_signal(&cond); pthread_mutex_unlock(&mtx); //解锁 sleep(1); } printf("thread 1 wanna end the line.So cancel thread 2./n"); //关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，子线程会在最近的取消点，退出 //线程，而在我们的代码里，最近的取消点肯定就是pthread_cond_wait()了。 pthread_cancel(tid); pthread_join(tid, NULL); printf("All done -- exiting/n"); return 0; }

三、信号量（sem）

如同进程一样，线程也可以通过信号量来实现通信，虽然是轻量级的。信号量函数的名字都以“sem_”打头。线程使用的基本信号量函数有四个。

1、信号量初始化。

int sem_init （sem_t *sem ， int pshared， unsigned int value）；

这是对由sem指定的信号量进行初始化，设置好它的共享选项（linux 只支持为0，即表示它是当前进程的局部信号量），然后给它一个初始值VALUE。

2、等待信号量。给信号量减1，然后等待直到信号量的值大于0。

int sem_wait（sem_t *sem）；

3、释放信号量。信号量值加1。并通知其他等待线程。

int sem_post（sem_t *sem）；

4、销毁信号量。我们用完信号量后都它进行清理。归还占有的一切资源。

int sem_destroy（sem_t *sem）；

  1. 01 #include
  2. 02 #include
  3. 03 #include
  4. 04 #include
  5. 05 #include
  6. 06 #include
  7. 07 #define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", func);return;}
  8. 08 typedef struct _PrivInfo
  9. 09 {
  10. 10 sem_t s1;
  11. 11 sem_t s2;
  12. 12 time_t end_time;
  13. 13 }PrivInfo;
  14. 14 static void info_init (PrivInfo* thiz);
  15. 15 static void info_destroy (PrivInfo* thiz);
  16. 16 static void pthread_func_1 (PrivInfo thiz);
  17. 17 static void pthread_func_2 (PrivInfo thiz);
  18. 18 int main (int argc, char** argv)
  19. 19 {
  20. 20 pthread_t pt_1 = 0;
  21. 21 pthread_t pt_2 = 0;
  22. 22 int ret = 0;
  23. 23 PrivInfo* thiz = NULL;
  24. 24 thiz = (PrivInfo* )malloc (sizeof (PrivInfo));
  25. 25 if (thiz == NULL)
  26. 26 {
  27. 27 printf ("[%s]: Failed to malloc priv./n");
  28. 28 return -1;
  29. 29 }
  30. 30 info_init (thiz);
  31. 31 ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);
  32. 32 if (ret != 0)
  33. 33 {
  34. 34 perror ("pthread_1_create:");
  35. 35 }
  36. 36 ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);
  37. 37 if (ret != 0)
  38. 38 {
  39. 39 perror ("pthread_2_create:");
  40. 40 }
  41. 41 pthread_join (pt_1, NULL);
  42. 42 pthread_join (pt_2, NULL);
  43. 43 info_destroy (thiz);
  44. 44 return 0;
  45. 45 }
  46. 46 static void info_init (PrivInfo* thiz)
  47. 47 {
  48. 48 return_if_fail (thiz != NULL);
  49. 49 thiz->end_time = time(NULL) + 10;
  50. 50 sem_init (&thiz->s1, 0, 1);
  51. 51 sem_init (&thiz->s2, 0, 0);
  52. 52 return;
  53. 53 }
  54. 54 static void info_destroy (PrivInfo* thiz)
  55. 55 {
  56. 56 return_if_fail (thiz != NULL);
  57. 57 sem_destroy (&thiz->s1);
  58. 58 sem_destroy (&thiz->s2);
  59. 59 free (thiz);
  60. 60 thiz = NULL;
  61. 61 return;
  62. 62 }
  63. 63 static void pthread_func_1 (PrivInfo thiz)
  64. 64 {
  65. 65 return_if_fail(thiz != NULL);
  66. 66 while (time(NULL) end_time)
  67. 67 {
  68. 68 sem_wait (&thiz->s2);
  69. 69 printf ("pthread1: pthread1 get the lock./n");
  70. 70 sem_post (&thiz->s1);
  71. 71 printf ("pthread1: pthread1 unlock/n");
  72. 72 sleep (1);
  73. 73 }
  74. 74 return;
  75. 75 }
  76. 76 static void pthread_func_2 (PrivInfo thiz)
  77. 77 {
  78. 78 return_if_fail (thiz != NULL);
  79. 79 while (time (NULL) end_time)
  80. 80 {
  81. 81 sem_wait (&thiz->s1);
  82. 82 printf ("pthread2: pthread2 get the unlock./n");
  83. 83 sem_post (&thiz->s2);
  84. 84 printf ("pthread2: pthread2 unlock./n");
  85. 85 sleep (1);
  86. 86 }
  87. 87 return;
  88. 88 }

复制代码

include #include #include #include

#include #include #define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", func);return;} typedef struct _PrivInfo { sem_t s1; sem_t s2; time_t end_time; }PrivInfo; static void info_init (PrivInfo thiz); static void info_destroy (PrivInfo thiz); static void pthread_func_1 (PrivInfo thiz); static void pthread_func_2 (PrivInfo thiz); int main (int argc, char argv) { pthread_t pt_1 = 0; pthread_t pt_2 = 0; int ret = 0; PrivInfo thiz = NULL; thiz = (PrivInfo )malloc (sizeof (PrivInfo)); if (thiz == NULL) { printf ("[%s]: Failed to malloc priv./n"); return -1; } info_init (thiz); ret = pthread_create (&pt_1, NULL, (void)pthread_func_1, thiz); if (ret != 0) { perror ("pthread_1_create:"); } ret = pthread_create (&pt_2, NULL, (void)pthread_func_2, thiz); if (ret != 0) { perror ("pthread_2_create:"); } pthread_join (pt_1, NULL); pthread_join (pt_2, NULL); info_destroy (thiz); return 0; } static void info_init (PrivInfo thiz) { return_if_fail (thiz != NULL); thiz->end_time = time(NULL) + 10; sem_init (&thiz->s1, 0, 1); sem_init (&thiz->s2, 0, 0); return; } static void info_destroy (PrivInfo thiz) { return_if_fail (thiz != NULL); sem_destroy (&thiz->s1); sem_destroy (&thiz->s2); free (thiz); thiz = NULL; return; } static void pthread_func_1 (PrivInfo thiz) { return_if_fail(thiz != NULL); while (time(NULL) end_time) { sem_wait (&thiz->s2); printf ("pthread1: pthread1 get the lock./n"); sem_post (&thiz->s1); printf ("pthread1: pthread1 unlock/n"); sleep (1); } return; } static void pthread_func_2 (PrivInfo thiz) { return_if_fail (thiz != NULL); while (time (NULL) end_time) { sem_wait (&thiz->s1); printf ("pthread2: pthread2 get the unlock./n"); sem_post (&thiz->s2); printf ("pthread2: pthread2 unlock./n"); sleep (1); } return; }

以上便是Linux下实现线程同步常用的三种方法，大家都知道，线程的最大的亮点便是资源共享性，而资源共享中的线程同步问题却是一大难点，希望小编的归纳能够对大家有所帮助！

免责声明： 凡标注转载/编译字样内容并非本站原创，转载目的在于传递更多信息，并不代表本网赞同其观点和对其真实性负责。如果你觉得本文好，欢迎推荐给朋友阅读；本文链接： https://m.nndssk.com/xtjc/276464ZgxszB.html。
猜你喜欢
最新应用
TapTap V2.84.0 手机版

TapTap V2.84.0 手机版

下载
软天空游戏盒应用

软天空游戏盒应用

下载
软天空游戏大全App

软天空游戏大全App

下载
菜鸡游戏不用排队版

菜鸡游戏不用排队版

下载
软天空游戏盒子手机版

软天空游戏盒子手机版

下载
软天空游戏盒正式版

软天空游戏盒正式版

下载
软天空游戏盒子app

软天空游戏盒子app

下载
软天空游戏盒子App

软天空游戏盒子App

下载
软天空游戏

软天空游戏

下载
菜鸡游戏App

菜鸡游戏App

下载
玩GO

玩GO

下载
好游快爆软件

好游快爆软件

下载
菜鸡游戏

菜鸡游戏

下载
葫芦侠App

葫芦侠App

下载
第五人格盒子软件

第五人格盒子软件

下载
热门应用
快手大屏版

快手大屏版

下载
嘿咻漫画

嘿咻漫画

下载
快狐短视频

快狐短视频

下载
微信

微信

下载
钢琴助手手机版

钢琴助手手机版

下载
钢琴助手最新版

钢琴助手最新版

下载
2345游戏盒

2345游戏盒

下载
北京交通app停车缴费

北京交通app停车缴费

下载
光环助手oppo版最新

光环助手oppo版最新

下载
精准天气预报几点几分

精准天气预报几点几分

下载
飞信

飞信

下载
华为鸿蒙os2.0系统

华为鸿蒙os2.0系统

下载
messenger free

messenger free

下载
海棠书屋自由阅读的小说阅读网

海棠书屋自由阅读的小说阅读网

下载
QQ

QQ

下载