Chinaunix首页 | 论坛 | 博客

徐龙秋

首页　| 　博文目录　| 　关于我

水江千波

  • 博客访问： 12962
  • 博文数量： 2
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 20
  • 用 户 组： 普通用户
  • 注册时间： 2016-06-16 15:14
个人简介

长久坚持，必见成效。 Bad programmers worry about the code. Good programmers worry about data structures and their relationships. --- Linus Torvals

文章分类

全部博文（2）

文章存档

2016年（2）

我的朋友
最近访客
推荐博文
相关博文
Linux 线程间的同步和互斥

分类： LINUX

2016-07-03 11:20:40

一、同步和互斥的概念

    操作系统中涉及到多线程的协调工作，主要关系有两种：同步和互斥。 同步用来解决任务的先后执行顺序，互斥用来解决共享资源的访问竞争。
    同步：又称为直接制约关系，是指多个线程(或者进程)为了合作完成任务，必须严格按照规定的某种先后顺序来执行。在代码结构中表现为，散布在不同线程之间的若干程序片段，它们的运行必须严格按照规定的某种次序来运行，这种先后次序依赖于要完成的特定任务。 
    互斥：又称为间接制约关系，是指系统中的某些共享资源，一次只允许一个线程访问。当一个线程访问临界资源是，其他线程必须等待，即互斥具有排他性。在代码结构中表现为，散布在不同线程之间的若干程序片段，当线程A运行该代码片段时，线程B、C、D…则不能再运行这一代码片段，只有等上一线程运行完改片段后，B线程才可以运行该片段。      
也就是说互斥是两个线程之间不可以同时运行，他们会互相排斥，必须等一个线程运行完毕，另一个才可以运行；而同步也是不能同时运行的，并且要按照一定的先后顺序来访问或者操作共享资源。

二、为什么要使用多线程技术

  • 避免阻塞，单个进程只有一个主线程，当主线程阻塞的时候，整个进程也就阻塞了，表现为APP卡顿了，无法再无响应其他操作。
  • 避免CPU空转，应用程序经常会涉及到网络访问，数据库操作，磁盘IO操作，这些操作的速度比cpu执行指令的速度慢很多，而在等待这些响应时，CPU不能处理新的请求，导致这种单线程的应用程序性能很差。
  • 提升效率，一个进程要独立拥有4DB的虚拟地址空间，而多个线程可以共享同一地址空间，线程的切换比进程的切换要快很多。

三、 Linux中实现线程间同步和互斥的技术

  • 互斥锁：mutex 包含头文件 #include  解决线程互斥问题

    互斥锁是一种用户态和内核态混合机制，需要两个部分合作完成。上面提到的函数并不是直接系统调用，而是glibc的库函数，这些函数在某些情况下(真的产生资源访问竞争的情况)会进行系统调用。mutex是用来防止资源竞争而采取的互斥技术手段，在很多情况下并不存在竞争，所以这种情况下lock和unlock只在用户态完成，不进行系统调用，避免了系统调用的开销。
    初始化：
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    pthread_mutex_init(pthread_mutex_t *mutex, constpthread_mutexattr_t *mutexattr);
    上锁:
    pthread_mutex_lock(pthread_mutex_t *mutex);
    pthread_mutex_trylock(pthread_mutex_t *mutex);
    pthread_mutex_timedlock(pthread_mutex_t*mutex, const struct timespec *abstime);
    解锁:
    pthread_mutex_unlock(pthread_mutex_t *mutex);
    销毁:
    pthread_mutex_unlock(pthread_mutex_t *mutex);
  • 信号量：semaphore  包含头文件 #include >     解决线程同步问题
    信号量是一个特殊的变量，程序对其访问都是原子操作，且只允许对它进行等待（即P(信号变量))和发送（即V(信号变量))信息操作。我们通常通过信号来解决多个进程对同一资源的访问竞争的问题，使在任一时刻只能有一个执行线程访问代码的临界区域，也可以说它是协调进程间的对同一资源的访问权，也就是用于同步进程的。
    初始化：
    sem_init(sem_t *sem, int pshared, unsignedint value);
    申请资源：信号量减1
    sem_wait(sem_t *sem);
    sem_trywait(sem_t*sem);
    释放资源：信号量加1
    sem_post(sem_t *sem);
  • 条件变量：cond 包含头文件 #include  解决线程同步问题
    条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，条件变量常和互斥锁结合使用。使用时，条件变量被用来阻塞一个线程，当条件不满足 时，线程往往解开相应的互斥锁并等待条件变量发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量**一个或多个正被此条件变量阻塞的线 程。这些线程将重新锁定互斥锁并重新测试条件是否满足。一般说来，条件变量被用来进行线程间的同步. 
    初始化：
    pthread_cond_t qready=PTHREAD_COND_INITIALIZER;
    pthread_cond_init(pthread_cond_t*cond,  constpthread_condattr_t *cond_attr);
    发送信号：
    pthread_cond_signal(pthread_cond_t*cond);
    等待信号：
    pthread_cond_wait(pthread_cond_t*cond,pthread_mutex_t* mutex);
    pthread_cond_timewait(pthread_cond_t*cond,pthread_mutex_t* mutex, conststruct timespec *abstime);
    销毁：
    pthread_cond_destroy(pthread_cond_t*cond);

三、例子和代码

    流水线生产面包，分为装包线程和封口线程。生产面包必须按照先装包再封口的先后顺序，这个顺序操作就是线程间的同步。假设封口需要用到剪刀，两个线程公用一把剪刀，两个线程对剪刀的使用就是互斥操作。
  • 使用互斥锁实现临界资源的互斥访问：三个线程使用同一把剪刀，进行买包封口工作
  1. /*
  2. *@Purpose: 使用互斥锁实现临界资源的互斥访问
  3. *@Author: xulongqiu163@163.com
  4. *@Created:2016-06-14
  5. */

  7. #include<stdio.h>
  8. #include<stdlib.h>
  9. #include<unistd.h>
  10. #include<pthread.h>
  11. #include<errno.h>

  13. #defineSHEAR_LIFE_CNT (5)
  14. #defineUSE_MUTEX

  16. /*declare functions*/
  17. void*sealBagA(void*arg);
  18. void*sealBagB(void*arg);
  19. void*sealBagC(void*arg);

  21. /*globle variable defination*/
  22. typedef structshear
  23. {
  24.         char name[10];
  25.         int lifeCnt;
  26. }sealBagShearT;

  28. sealBagShearT gShear=
  29. {
  30.         .name = "001",
  31.         .lifeCnt =SHEAR_LIFE_CNT
  32. };
  33. #ifdefUSE_MUTEX
  34. pthread_mutex_tgMutex;
  35. #endif

  37. /*main entry point*/
  38. int main(intargc, char** argv)
  39. {
  40.         pthread_tidA, idB,idC;
  41.         int ret;

  43. #ifdefUSE_MUTEX
  44.         /*init the mutex*/
  45.         pthread_mutex_init(&gMutex, NULL);
  46.         printf("init:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  47. #endif
  48.         /*create thread A*/
  49.         ret=pthread_create(&idA, NULL, sealBagA,NULL);
  50.         if(ret< 0)
  51.         {
  52.                 perror("create sealBagA:");
  53.                 exit(-1);
  54.         }

  56.         /*create thread B*/
  57.         ret=pthread_create(&idB, NULL, sealBagB,NULL);
  58.         if(ret< 0)
  59.         {
  60.                 perror("create sealBagB:");
  61.                 exit(-1);
  62.         }
  63.         /*create thread C*/
  64.         ret=pthread_create(&idC, NULL, sealBagC,NULL);
  65.         if(ret< 0)
  66.         {
  67.                 perror("create sealBagC:");
  68.                 exit(-1);
  69.         }

  71.         /*wait sealBagA thread run over*/
  72.         pthread_join(idA, NULL);
  73.         /*wait sealBagB thread run over*/
  74.         pthread_join(idB, NULL);
  75.         /*wait sealBagC thread run over*/
  76.         pthread_join(idC, NULL);

  78.         return 0;
  79. }

  81. /*sealBagA thread*/
  82. void*sealBagA(void*arg)
  83. {
  84.         while(1)
  85.         {
  86.         #ifdef USE_MUTEX
  87.                 /*lock*/
  88.                 printf("A try to get mutex\n");
  89.                 pthread_mutex_lock(&gMutex);
  90.                 printf("lockA:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  91.   #endif
  92.                 if(gShear.lifeCnt > 0)
  93.                 {
  94.                         usleep(1000);
  95.                         printf("workerA is using shear:%s, available life=%d\n", gShear.name, gShear.lifeCnt);
  96.                         gShear.lifeCnt--;

  98.                 #ifdef USE_MUTEX
  99.                         /*unlock*/
  100.                         pthread_mutex_unlock(&gMutex);
  101.                         printf("unlockA:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  102.     #endif
  103.                 }
  104.                 else
  105.                 {
  106.                         printf("workerA want to use shear:%s, but it does not work\n", gShear.name);
  107.                 #ifdef USE_MUTEX
  108.                         /*unlock*/
  109.                         pthread_mutex_unlock(&gMutex);
  110.                         printf("unlockA:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  111.     #endif
  112.                         break;
  113.                 }
  114.                 pthread_yield();
  115.         }
  116.         return (void*)0;
  117. }

  119. /*sealBagB thread*/
  120. void*sealBagB(void*arg)
  121. {
  122.         while(1)
  123.         {
  124.         #ifdef USE_MUTEX
  125.                 /*lock*/
  126.                 printf("B try to mutex\n");
  127.                 pthread_mutex_lock(&gMutex);
  128.                 printf("lockB:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  129.         #endif

  131.                 if(gShear.lifeCnt > 0)
  132.                 {
  133.                         usleep(1000);
  134.                         printf("workerB is using shear:%s, available life=%d\n", gShear.name, gShear.lifeCnt);
  135.                         gShear.lifeCnt--;
  136.                 #ifdef USE_MUTEX
  137.                         pthread_mutex_unlock(&gMutex);
  138.                         printf("unlockB:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  139.                 #endif
  140.                 }
  141.                 else
  142.                 {
  143.                         printf("workerB want to use shear:%s, but it does not work\n", gShear.name);
  144.                 #ifdef USE_MUTEX
  145.                         /*unlock*/
  146.                         pthread_mutex_unlock(&gMutex);
  147.                         printf("unlockB:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  148.                 #endif
  149.                         break;
  150.                 }
  151.                 pthread_yield();
  152.         }
  153.   return(void*)0;
  154. }
  155. /*sealBagC thread*/
  156. void*sealBagC(void*arg)
  157. {
  158.         while(1)
  159.         {
  160.         #ifdef USE_MUTEX
  161.                 /*lock*/
  162.                 printf("C try to mutex\n");
  163.                 pthread_mutex_lock(&gMutex);
  164.                 printf("lockC:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  165.         #endif

  167.                 if(gShear.lifeCnt > 0)
  168.                 {
  169.                         usleep(1000);
  170.                         printf("workerC is using shear:%s, available life=%d\n", gShear.name, gShear.lifeCnt);
  171.                         gShear.lifeCnt--;
  172.                 #ifdef USE_MUTEX
  173.                         pthread_mutex_unlock(&gMutex);
  174.                         printf("unlockC:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  175.                 #endif
  176.                 }
  177.                 else
  178.                 {
  179.                         printf("workerC want to use shear:%s, but it does not work\n", gShear.name);
  180.                 #ifdef USE_MUTEX
  181.                         /*unlock*/
  182.                         pthread_mutex_unlock(&gMutex);
  183.                         printf("unlockC:gMutex.__data.__lock=%d\n",gMutex.__data.__lock);
  184.                 #endif
  185.                         break;
  186.                 }
  187.                 pthread_yield();
  188.         }
  189.   return(void*)0;
  190. }
  1. result：
  2. init:gMutex.__data.__lock=0
  3. C try to mutex
  4. lockC:gMutex.__data.__lock=1
  5. B try to mutex
  6. A try to get mutex
  7. workerC is using shear:001, available life=5
  8. unlockC:gMutex.__data.__lock=0
  9. lockB:gMutex.__data.__lock=2
  10. C try to mutex
  11. workerB is using shear:001, available life=4
  12. unlockB:gMutex.__data.__lock=0
  13. lockA:gMutex.__data.__lock=2
  14. B try to mutex
  15. workerA is using shear:001, available life=3
  16. unlockA:gMutex.__data.__lock=0
  17. lockC:gMutex.__data.__lock=2
  18. A try to get mutex
  19. workerC is using shear:001, available life=2
  20. unlockC:gMutex.__data.__lock=0
  21. lockB:gMutex.__data.__lock=2
  22. C try to mutex
  23. workerB is using shear:001, available life=1
  24. lockA:gMutex.__data.__lock=2
  25. workerA want to use shear:001, but it does not work
  26. unlockA:gMutex.__data.__lock=0
  27. lockC:gMutex.__data.__lock=2
  28. workerC want to use shear:001, but it does not work
  29. unlockC:gMutex.__data.__lock=0
  30. unlockB:gMutex.__data.__lock=0
  31. B try to mutex
  32. lockB:gMutex.__data.__lock=1
  33. workerB want to use shear:001, but it does not work
  34. unlockB:gMutex.__data.__lock=0
  • 使用信号量实现线程间的同步：装面包和封口两个线程协调工作，先装面包，再封口
  1. /*
  2. *@Purpose: 使用信号量实现线程间的同步
  3. *@Author: xulongqiu163@163.com
  4. *@Created:2016-06-14
  5. */

  7. #include<stdio.h>
  8. #include<stdlib.h>
  9. #include<unistd.h>
  10. #include<pthread.h>
  11. #include<errno.h>
  12. #include<semaphore.h>

  14. #defineBREAD_BAG_CNT (5)
  15. #undefUSE_SEM
  16. #defineUSE_SEM

  18. /*declare functions*/
  19. void*sealBag(void*arg);
  20. void*setBread(void*arg);
  21. int breadBagInit(intstartNum);

  23. typedef enumbagStatus
  24. {
  25.         BAG_EMPTY= 0,
  26.         BAG_SET,
  27.         BAG_SEAL
  28. }BAG_STATUS_T;

  30. typedef structbreadBag
  31. {
  32.         int number;
  33.   BAG_STATUS_T status;
  34. }BREAD_BAG_T;

  36. BREAD_BAG_TgBreadBag[BREAD_BAG_CNT];
  37. #ifdefUSE_SEM
  38. sem_t gSemA, gSemB;
  39. #endif
  40. /*main entry point*/
  41. int main(intargc, char** argv)
  42. {
  43.         pthread_tidA, idB;
  44.         int ret =0;

  46. #ifdefUSE_SEM
  47.         /*A sem init value 1*/
  48.   ret = sem_init(&gSemA, 0, 0);
  49.         /*B sem init value 0*/
  50.   ret += sem_init(&gSemB, 0, 1);
  51.         if( 0)
  52.         {
  53.                 perror("sem_init:");
  54.         }
  55. #endif
  56.   /*initbags*/
  57.         ret= breadBagInit(1);
  58.         printf("init bread %d bags\n", ret);

  60.         /*create thread sealBag*/
  61.         ret=pthread_create(&idA, NULL, sealBag, NULL);
  62.         if(ret< 0)
  63.         {
  64.                 perror("create sealBag:");
  65.         }

  67.         /*create thread B*/
  68.         ret=pthread_create(&idB, NULL, setBread,NULL);
  69.         if(ret< 0)
  70.         {
  71.                 perror("create setBread:");
  72.         }

  74.         /*wait sealBag thread run over*/
  75.         pthread_join(idA, NULL);
  76.         /*wait setBread thread run over*/
  77.         pthread_join(idB, NULL);

  79.         printf("The machine producted %d bags bread totally\n", BREAD_BAG_CNT);
  80.         return 0;
  81. }

  83. int breadBagInit(intstartNum)
  84. {
  85.         int i =0;
  86.         for(;i < BREAD_BAG_CNT;i++)
  87.         {
  88.                 gBreadBag.number = startNum++;
  89.                 gBreadBag.status = BAG_EMPTY;
  90.         }

  92.         return i;
  93. }

  95. /*sealBag thread*/
  96. void*sealBag(void*arg)
  97. {
  98.         int sealedBags = 0;
  99.         while(1)
  100.         {
  101.         #ifdef USE_SEM
  102.                 /*P operation value-1*/
  103.                 sem_wait(&gSemA);
  104.         #endif

  106.                 if(sealedBags< BREAD_BAG_CNT)
  107.                 {
  108.                         usleep(1000);
  109.                         gBreadBag[sealedBags].status= BAG_SEAL;
  110.                         printf("bag:%d has been sealed\n",gBreadBag[sealedBags].number);
  111.                         sealedBags++;
  112.                 #ifdef USE_SEM
  113.                         /*V operation value+1*/
  114.                         sem_post(&gSemB);
  115.                 #endif
  116.                 }
  117.                 else
  118.                 {
  119.                         printf("All the bags have been sealed\n");
  120.                 #ifdef USE_SEM
  121.                         /*V operation value+1*/
  122.                         sem_post(&gSemB);
  123.                 #endif
  124.                         break;
  125.                 }
  126.         }
  127.         return (void*)0;
  128. }

  130. /*setBread thread*/
  131. void*setBread(void*arg)
  132. {
  133.         int setBags = 0;
  134.         while(1)
  135.         {
  136.         #ifdef USE_SEM
  137.                 /*p operation value-1*/
  138.                 sem_wait(&gSemB);
  139.         #endif
  140.                 if(setBags< BREAD_BAG_CNT)
  141.                 {
  142.                         usleep(1000);
  143.                         if(gBreadBag[setBags].status== BAG_SEAL)
  144.                         {
  145.                                 printf("bag:%d has been sealed without set\n", gBreadBag[setBags].number);
  146.                         }
  147.                         else
  148.                         {
  149.                                 gBreadBag[setBags].status= BAG_SET;
  150.                                 printf("bag:%d has been set\n",gBreadBag[setBags].number);
  151.                         }
  152.                         setBags++;
  153.                 #ifdef USE_SEM
  154.                         /*V operation value+1*/
  155.                         sem_post(&gSemA);
  156.                 #endif
  157.                 }
  158.                 else
  159.                 {
  160.                         printf("All the bags have been set\n");
  161.                 #ifdef USE_SEM
  162.                         /*V operation value+1*/
  163.                         sem_post(&gSemA);
  164.                 #endif
  165.                         break;
  166.                 }
  167.         }
  168.   return(void*)0;
  169. }
  1. result：
  2. init bread 5 bags
  3. bag:1 has been set
  4. bag:1 has been sealed
  5. bag:2 has been set
  6. bag:2 has been sealed
  7. bag:3 has been set
  8. bag:3 has been sealed
  9. bag:4 has been set
  10. bag:4 has been sealed
  11. bag:5 has been set
  12. bag:5 has been sealed
  13. All the bags have been set
  14. All the bags have been sealed
  15. The machine producted 5 bags bread totally
  • 使用条件变量和互斥锁实现线程间的同步：装面包和封口两个线程协调工作，先装面包，再封口
  1. /*
  2.  *@Purpose: 使用条件变量实现线程间的同步
  3.  *@Author: xulongqiu163@163.com
  4.  *@Created: 2016-06-14
  5. */

  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <pthread.h>
  11. #include <errno.h>

  13. #define BREAD_BAG_CNT (5)
  14. #undef USE_COND
  15. #define USE_COND

  17. /*declare functions*/
  18. void* sealBag(void* arg);
  19. void* setBread(void* arg);
  20. int breadBagInit(int startNum);

  22. typedef enum bagStatus
  23. {
  24.     BAG_EMPTY = 0,
  25.     BAG_SET,
  26.     BAG_SEAL
  27. }BAG_STATUS_T;

  29. typedef struct breadBag
  30. {
  31.     int number;
  32.   BAG_STATUS_T status;    
  33. }BREAD_BAG_T;

  35. BREAD_BAG_T gBreadBag[BREAD_BAG_CNT];
  36. int gFinishBags = 0;
  37. #ifdef USE_COND
  38. pthread_mutex_t mxt;
  39. pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  40. #endif
  41. /*main entry point*/
  42. int main(int argc, char** argv)
  43. {
  44.     pthread_t idA, idB;
  45.     int ret = 0;

  47. #ifdef USE_COND
  48.     pthread_mutex_init(&mxt, NULL);
  49. #endif
  50.   /*init bags*/
  51.     ret = breadBagInit(1);
  52.     printf("init bread %d bags\n", ret);

  54.     /*create thread sealBag*/
  55.     ret=pthread_create(&idA, NULL, sealBag, NULL);
  56.     if(ret < 0)
  57.     {
  58.         perror("create sealBag:");
  59.     }

  61.     /*create thread B*/
  62.     ret=pthread_create(&idB, NULL, setBread, NULL);
  63.     if(ret < 0)
  64.     {
  65.         perror("create setBread:");
  66.     }

  68.     /*wait sealBag thread run over*/
  69.     pthread_join(idA, NULL);
  70.     /*wait setBread thread run over*/
  71.     pthread_join(idB, NULL);

  73.     printf("The machine producted %d bags bread totally\n", BREAD_BAG_CNT);
  74.     return 0;
  75. }

  77. int breadBagInit(int startNum)
  78. {
  79.     int i = 0;
  80.     for(; i < BREAD_BAG_CNT; i++)
  81.     {
  82.         gBreadBag[i].number = startNum++;
  83.         gBreadBag[i].status = BAG_EMPTY;
  84.     }

  86.     return i;
  87. }

  89. /*sealBag thread*/
  90. void* sealBag(void* arg)
  91. {
  92.     while(1)
  93.     {
  94.     #ifdef USE_COND
  95.         pthread_mutex_lock(&mxt);
  96.     #endif
  97.         if(gFinishBags < BREAD_BAG_CNT)
  98.         {
  99.             if(gBreadBag[gFinishBags].status == BAG_EMPTY)
  100.             {
  101.                 printf("try to seal bag:%d\n",gBreadBag[gFinishBags].number);
  102.             #ifdef USE_COND
  103.                 pthread_cond_wait(&cond, &mxt);
  104.             #endif
  105.             }
  106.             else
  107.             {
  108.                 usleep(300);
  109.                 gBreadBag[gFinishBags].status = BAG_SEAL;
  110.                 printf("bag:%d has been sealed\n",gBreadBag[gFinishBags].number);
  111.                 gFinishBags++;
  112.             #ifdef USE_COND
  113.                 pthread_cond_signal(&cond);
  114.             #endif
  115.             }
  116.         #ifdef USE_COND
  117.             pthread_mutex_unlock(&mxt);
  118.         #endif
  119.         }
  120.         else
  121.         {
  122.             printf("All the bags have been sealed\n");
  123.         #ifdef USE_COND
  124.             pthread_mutex_unlock(&mxt);
  125.         #endif
  126.             break;
  127.         }
  128.     }
  129.     return (void*)0;
  130. }

  132. /*setBread thread*/
  133. void* setBread(void* arg)
  134. {
  135.     while(1)
  136.     {
  137.     #ifdef USE_COND
  138.         pthread_mutex_lock(&mxt);
  139.     #endif
  140.         if(gFinishBags < BREAD_BAG_CNT)
  141.         {
  142.             if(gBreadBag[gFinishBags].status == BAG_EMPTY)
  143.             {
  144.                 usleep(1000);
  145.                 gBreadBag[gFinishBags].status = BAG_SET;
  146.              printf("bag:%d has been set\n",gBreadBag[gFinishBags].number);
  147.             #ifdef USE_COND
  148.                 pthread_cond_signal(&cond);
  149.             #endif
  150.             }
  151.             else
  152.             {
  153.             #ifdef USE_COND
  154.                 pthread_cond_wait(&cond, &mxt);
  155.             #endif
  156.             }
  157.         #ifdef USE_COND
  158.             pthread_mutex_unlock(&mxt);
  159.         #endif
  160.         }
  161.         else
  162.         {
  163.             printf("All the bags have been set\n");
  164.         #ifdef USE_COND
  165.             pthread_mutex_unlock(&mxt);
  166.         #endif
  167.             break;
  168.         }
  169.     }
  170.   return (void*)0;
  171. }
  1. Result:
  2. init bread 5 bags
  3. bag:1 has been set
  4. bag:1 has been sealed
  5. try to seal bag:2
  6. bag:2 has been set
  7. bag:2 has been sealed
  8. try to seal bag:3
  9. bag:3 has been set
  10. bag:3 has been sealed
  11. try to seal bag:4
  12. bag:4 has been set
  13. bag:4 has been sealed
  14. try to seal bag:5
  15. bag:5 has been set
  16. bag:5 has been sealed
  17. All the bags have been sealed
  18. All the bags have been set
  19. The machine producted 5 bags bread totally



阅读(1101) | 评论(0) | 转发(0) |
0

上一篇：没有了

下一篇：Linux 之mutex 源码分析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6