¼Ó¹·¹·ÏµÍ³ - ϵͳ¹âÅÌÏÂÔØÍøÕ¾£¡

µ±Ç°Î»Ö㺼ӹ·¹·ÏµÍ³ > ϵͳ½Ì³Ì > Linux½Ì³Ì > ÏêÏ¸Ò³Ãæ

Ïß³Ìͬ²½µÄ·½·¨ÓÐÄÄЩ£¿LinuxÏÂʵÏÖÏß³Ìͬ²½µÄÈýÖÖ·½·¨

ʱ¼ä£º2021-04-11 À´Ô´£º¼Ó¹·¹·ÏµÍ³ ×÷Õߣºchunhua

¡¡¡¡Ïß³Ìͬ²½µÄ·½·¨ÓÐÄÄЩ£¿ÔÚ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 <cstdio>
  2. 02#include <cstdlib>
  3. 03#include <unistd.h>
  4. 04#include <pthread.h>
  5. 05#include "iostream"
  6. 06using namespace std;
  7. 07pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
  8. 08int tmp;
  9. 09void* thread(void *arg)
  10. 10{
  11. 11cout << "thread id is " << pthread_self() << endl;
  12. 12pthread_mutex_lock(&mutex);
  13. 13tmp = 12;
  14. 14cout << "Now a is " << tmp << endl;
  15. 15pthread_mutex_unlock(&mutex);
  16. 16return NULL;
  17. 17}
  18. 18int main()
  19. 19{
  20. 20pthread_t id;
  21. 21cout << "main thread id is " << pthread_self() << endl;
  22. 22tmp = 3;
  23. 23cout << "In main func tmp = " << tmp << endl;
  24. 24if (!pthread_create(&id, NULL, thread, NULL))
  25. 25{
  26. 26cout << "Create thread success!" << endl;
  27. 27}
  28. 28else
  29. 29{
  30. 30cout << "Create thread failed!" << endl;
  31. 31}
  32. 32pthread_join(id, NULL);
  33. 33pthread_mutex_destroy(&mutex);
  34. 34return 0;
  35. 35}
  36. 36//±àÒ룺g++ -o thread testthread.cpp -lpthread
¸´ÖÆ´úÂë
#include <cstdio> #include <cstdlib> #include <unistd.h> #include <pthread.h> #include "iostream" using namespace std; pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; int tmp; void* thread(void *arg) { cout << "thread id is " << pthread_self() << endl; pthread_mutex_lock(&mutex); tmp = 12; cout << "Now a is " << tmp << endl; pthread_mutex_unlock(&mutex); return NULL; } int main() { pthread_t id; cout << "main thread id is " << pthread_self() << endl; tmp = 3; cout << "In main func tmp = " << tmp << endl; if (!pthread_create(&id, NULL, thread, NULL)) { cout << "Create thread success!" << endl; } else { cout << "Create thread failed!" << endl; } pthread_join(id, NULL); pthread_mutex_destroy(&mutex); return 0; } //±àÒ룺g++ -o thread testthread.cpp -lpthread

¡¡¡¡¶þ¡¢Ìõ¼þ±äÁ¿£¨cond£©

¡¡¡¡Ó뻥³âËø²»Í¬£¬Ìõ¼þ±äÁ¿ÊÇÓÃÀ´µÈ´ý¶ø²»ÊÇÓÃÀ´ÉÏËøµÄ¡£Ìõ¼þ±äÁ¿ÓÃÀ´×Ô¶¯×èÈûÒ»¸öỊ̈߳¬Ö±µ½Ä³ÌØÊâÇé¿ö·¢ÉúΪֹ¡£Í¨³£Ìõ¼þ±äÁ¿ºÍ»¥³âËøÍ¬Ê±Ê¹Óá£Ìõ¼þ±äÁ¿·ÖΪÁ½²¿·Ö£º Ìõ¼þºÍ±äÁ¿¡£Ìõ¼þ±¾ÉíÊÇÓÉ»¥³âÁ¿±£»¤µÄ¡£Ïß³ÌÔڸıäÌõ¼þ״̬ǰÏÈÒªËø×¡»¥³âÁ¿¡£Ìõ¼þ±äÁ¿Ê¹ÎÒÃÇ¿ÉÒÔ˯ÃߵȴýijÖÖÌõ¼þ³öÏÖ¡£Ìõ¼þ±äÁ¿ÊÇÀûÓÃÏ̼߳乲ÏíµÄÈ«¾Ö±äÁ¿½øÐÐͬ²½µÄÒ»ÖÖ»úÖÆ£¬Ö÷Òª°üÀ¨Á½¸ö¶¯×÷£ºÒ»¸öÏ̵߳ȴý“Ìõ¼þ±äÁ¿µÄÌõ¼þ³ÉÁ¢”¶ø¹ÒÆð£»ÁíÒ»¸öÏß³Ìʹ“Ìõ¼þ³ÉÁ¢”£¨¸ø³öÌõ¼þ³ÉÁ¢Ðźţ©¡£Ìõ¼þµÄ¼ì²âÊÇÔÚ»¥³âËøµÄ±£»¤Ï½øÐеÄ¡£Èç¹ûÒ»¸öÌõ¼þΪ¼Ù£¬Ò»¸öÏß³Ì×Ô¶¯×èÈû£¬²¢Êͷŵȴý״̬¸Ä±äµÄ»¥³âËø¡£Èç¹ûÁíÒ»¸öÏ̸߳ıäÁËÌõ¼þ£¬Ëü·¢ÐźŸø¹ØÁªµÄÌõ¼þ±äÁ¿£¬»½ÐÑÒ»¸ö»ò¶à¸öµÈ´ýËüµÄỊ̈߳¬ÖØÐ»ñµÃ»¥³âËø£¬ÖØÐÂÆÀ¼ÛÌõ¼þ¡£Èç¹ûÁ½½ø³Ì¹²Ïí¿É¶ÁдµÄÄڴ棬Ìõ¼þ±äÁ¿¿ÉÒÔ±»ÓÃÀ´ÊµÏÖÕâÁ½½ø³Ì¼äµÄÏß³Ìͬ²½¡£

¡¡¡¡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 <stdio.h>
  3. 03#include <pthread.h>
  4. 04#include "stdlib.h"
  5. 05#include "unistd.h"
  6. 06pthread_mutex_t mutex;
  7. 07pthread_cond_t cond;
  8. 08void hander(void *arg)
  9. 09{
  10. 10free(arg);
  11. 11(void)pthread_mutex_unlock(&mutex);
  12. 12}
  13. 13void *thread1(void *arg)
  14. 14{
  15. 15pthread_cleanup_push(hander, &mutex);
  16. 16while(1)
  17. 17{
  18. 18printf("thread1 is running\n");
  19. 19pthread_mutex_lock(&mutex);
  20. 20pthread_cond_wait(&cond, &mutex);
  21. 21printf("thread1 applied the condition\n");
  22. 22pthread_mutex_unlock(&mutex);
  23. 23sleep(4);
  24. 24}
  25. 25pthread_cleanup_pop(0);
  26. 26}
  27. 27void *thread2(void *arg)
  28. 28{
  29. 29while(1)
  30. 30{
  31. 31printf("thread2 is running\n");
  32. 32pthread_mutex_lock(&mutex);
  33. 33pthread_cond_wait(&cond, &mutex);
  34. 34printf("thread2 applied the condition\n");
  35. 35pthread_mutex_unlock(&mutex);
  36. 36sleep(1);
  37. 37}
  38. 38}
  39. 39int main()
  40. 40{
  41. 41pthread_t thid1,thid2;
  42. 42printf("condition variable study!\n");
  43. 43pthread_mutex_init(&mutex, NULL);
  44. 44pthread_cond_init(&cond, NULL);
  45. 45pthread_create(&thid1, NULL, thread1, NULL);
  46. 46pthread_create(&thid2, NULL, thread2, NULL);
  47. 47sleep(1);
  48. 48do
  49. 49{
  50. 50pthread_cond_signal(&cond);
  51. 51}while(1);
  52. 52sleep(20);
  53. 53pthread_exit(0);
  54. 54return 0;
  55. 55}
¸´ÖÆ´úÂë
[cpp] view plain copy #include <stdio.h> #include <pthread.h> #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\n"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread1 applied the condition\n"); pthread_mutex_unlock(&mutex); sleep(4); } pthread_cleanup_pop(0); } void *thread2(void *arg) { while(1) { printf("thread2 is running\n"); pthread_mutex_lock(&mutex); pthread_cond_wait(&cond, &mutex); printf("thread2 applied the condition\n"); pthread_mutex_unlock(&mutex); sleep(1); } } int main() { pthread_t thid1,thid2; printf("condition variable study!\n"); 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 <pthread.h>
  2. 02#include <unistd.h>
  3. 03#include "stdio.h"
  4. 04#include "stdlib.h"
  5. 05static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
  6. 06static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  7. 07struct node
  8. 08{
  9. 09int n_number;
  10. 10struct node *n_next;
  11. 11}*head = NULL;
  12. 12static void cleanup_handler(void *arg)
  13. 13{
  14. 14printf("Cleanup handler of second thread./n");
  15. 15free(arg);
  16. 16(void)pthread_mutex_unlock(&mtx);
  17. 17}
  18. 18static void *thread_func(void *arg)
  19. 19{
  20. 20struct node *p = NULL;
  21. 21pthread_cleanup_push(cleanup_handler, p);
  22. 22while (1)
  23. 23{
  24. 24//Õâ¸ömutexÖ÷ÒªÊÇÓÃÀ´±£Ö¤pthread_cond_waitµÄ²¢·¢ÐÔ
  25. 25pthread_mutex_lock(&mtx);
  26. 26while (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//ÓÃÕâ¸öÁ÷³ÌÊDZȽÏÇå³þµÄ
  36. 36pthread_cond_wait(&cond, &mtx);
  37. 37p = head;
  38. 38head = head->n_next;
  39. 39printf("Got %d from front of queue/n", p->n_number);
  40. 40free(p);
  41. 41}
  42. 42pthread_mutex_unlock(&mtx); //ÁÙ½çÇøÊý¾Ý²Ù×÷Íê±Ï£¬ÊÍ·Å»¥³âËø
  43. 43}
  44. 44pthread_cleanup_pop(0);
  45. 45return 0;
  46. 46}
  47. 47int main(void)
  48. 48{
  49. 49pthread_t tid;
  50. 50int i;
  51. 51struct node *p;
  52. 52//×ÓÏ̻߳áÒ»Ö±µÈ´ý×ÊÔ´£¬ÀàËÆÉú²úÕߺÍÏû·ÑÕߣ¬µ«ÊÇÕâÀïµÄÏû·ÑÕß¿ÉÒÔÊǶà¸öÏû·ÑÕߣ¬¶ø
  53. 53//²»½ö½öÖ§³ÖÆÕͨµÄµ¥¸öÏû·ÑÕߣ¬Õâ¸öÄ£ÐÍËäÈ»¼òµ¥£¬µ«ÊǺÜÇ¿´ó
  54. 54pthread_create(&tid, NULL, thread_func, NULL);
  55. 55sleep(1);
  56. 56for (i = 0; i < 10; i++)
  57. 57{
  58. 58p = (struct node*)malloc(sizeof(struct node));
  59. 59p->n_number = i;
  60. 60pthread_mutex_lock(&mtx); //ÐèÒª²Ù×÷headÕâ¸öÁÙ½ç×ÊÔ´£¬ÏȼÓËø£¬
  61. 61p->n_next = head;
  62. 62head = p;
  63. 63pthread_cond_signal(&cond);
  64. 64pthread_mutex_unlock(&mtx); //½âËø
  65. 65sleep(1);
  66. 66}
  67. 67printf("thread 1 wanna end the line.So cancel thread 2./n");
  68. 68//¹ØÓÚpthread_cancel£¬ÓÐÒ»µã¶îÍâµÄ˵Ã÷£¬ËüÊÇ´ÓÍⲿÖÕÖ¹×ÓỊ̈߳¬×ÓÏ̻߳áÔÚ×î½üµÄÈ¡Ïûµã£¬Í˳ö
  69. 69//Ị̈߳¬¶øÔÚÎÒÃǵĴúÂëÀ×î½üµÄÈ¡Ïûµã¿Ï¶¨¾ÍÊÇpthread_cond_wait()ÁË¡£
  70. 70pthread_cancel(tid);
  71. 71pthread_join(tid, NULL);
  72. 72printf("All done -- exiting/n");
  73. 73return 0;
  74. 74}
¸´ÖÆ´úÂë
#include <pthread.h> #include <unistd.h> #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);£¬ÔÙ¶ÁÈ¡×ÊÔ´ //ÓÃÕâ¸öÁ÷³ÌÊDZȽÏÇå³þµÄ 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 < 10; i++) { p = (struct node*)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 <stdlib.h>
  2. 02#include <stdio.h>
  3. 03#include <unistd.h>
  4. 04#include <pthread.h>
  5. 05#include <semaphore.h>
  6. 06#include <errno.h>
  7. 07#define return_if_fail(p) if((p) == 0){printf ("[%s]:func error!/n", __func__);return;}
  8. 08typedef struct _PrivInfo
  9. 09{
  10. 10sem_t s1;
  11. 11sem_t s2;
  12. 12time_t end_time;
  13. 13}PrivInfo;
  14. 14static void info_init (PrivInfo* thiz);
  15. 15static void info_destroy (PrivInfo* thiz);
  16. 16static void* pthread_func_1 (PrivInfo* thiz);
  17. 17static void* pthread_func_2 (PrivInfo* thiz);
  18. 18int main (int argc, char** argv)
  19. 19{
  20. 20pthread_t pt_1 = 0;
  21. 21pthread_t pt_2 = 0;
  22. 22int ret = 0;
  23. 23PrivInfo* thiz = NULL;
  24. 24thiz = (PrivInfo* )malloc (sizeof (PrivInfo));
  25. 25if (thiz == NULL)
  26. 26{
  27. 27printf ("[%s]: Failed to malloc priv./n");
  28. 28return -1;
  29. 29}
  30. 30info_init (thiz);
  31. 31ret = pthread_create (&pt_1, NULL, (void*)pthread_func_1, thiz);
  32. 32if (ret != 0)
  33. 33{
  34. 34perror ("pthread_1_create:");
  35. 35}
  36. 36ret = pthread_create (&pt_2, NULL, (void*)pthread_func_2, thiz);
  37. 37if (ret != 0)
  38. 38{
  39. 39perror ("pthread_2_create:");
  40. 40}
  41. 41pthread_join (pt_1, NULL);
  42. 42pthread_join (pt_2, NULL);
  43. 43info_destroy (thiz);
  44. 44return 0;
  45. 45}
  46. 46static void info_init (PrivInfo* thiz)
  47. 47{
  48. 48return_if_fail (thiz != NULL);
  49. 49thiz->end_time = time(NULL) + 10;
  50. 50sem_init (&thiz->s1, 0, 1);
  51. 51sem_init (&thiz->s2, 0, 0);
  52. 52return;
  53. 53}
  54. 54static void info_destroy (PrivInfo* thiz)
  55. 55{
  56. 56return_if_fail (thiz != NULL);
  57. 57sem_destroy (&thiz->s1);
  58. 58sem_destroy (&thiz->s2);
  59. 59free (thiz);
  60. 60thiz = NULL;
  61. 61return;
  62. 62}
  63. 63static void* pthread_func_1 (PrivInfo* thiz)
  64. 64{
  65. 65return_if_fail(thiz != NULL);
  66. 66while (time(NULL) < thiz->end_time)
  67. 67{
  68. 68sem_wait (&thiz->s2);
  69. 69printf ("pthread1: pthread1 get the lock./n");
  70. 70sem_post (&thiz->s1);
  71. 71printf ("pthread1: pthread1 unlock/n");
  72. 72sleep (1);
  73. 73}
  74. 74return;
  75. 75}
  76. 76static void* pthread_func_2 (PrivInfo* thiz)
  77. 77{
  78. 78return_if_fail (thiz != NULL);
  79. 79while (time (NULL) < thiz->end_time)
  80. 80{
  81. 81sem_wait (&thiz->s1);
  82. 82printf ("pthread2: pthread2 get the unlock./n");
  83. 83sem_post (&thiz->s2);
  84. 84printf ("pthread2: pthread2 unlock./n");
  85. 85sleep (1);
  86. 86}
  87. 87return;
  88. 88}
¸´ÖÆ´úÂë
#include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <pthread.h> #include <semaphore.h> #include <errno.h> #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) < thiz->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) < thiz->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ÏÂʵÏÖÏß³Ìͬ²½³£ÓõÄÈýÖÖ·½·¨£¬´ó¼Ò¶¼ÖªµÀ£¬Ï̵߳Ä×î´óµÄÁÁµã±ãÊÇ×ÊÔ´¹²ÏíÐÔ£¬¶ø×ÊÔ´¹²ÏíÖеÄÏß³Ìͬ²½ÎÊÌâÈ´ÊÇÒ»´óÄѵ㣬ϣÍûС±àµÄ¹éÄÉÄܹ»¶Ô´ó¼ÒÓÐËù°ïÖú£¡

·ÖÏíµ½£º

ϵͳ½Ì³ÌÀ¸Ä¿

À¸Ä¿ÈÈÃŽ̳Ì

ÈËÆø½Ì³ÌÅÅÐÐ

Õ¾³¤ÍƼö

ÈÈÃÅϵͳÏÂÔØ