当前位置:   article > 正文

C/C++ 之 多线程 百度、华为、360 面试面试题汇总(一)_360面试题c++ 线程

360面试题c++ 线程

以下提供答案参考:

第一题:线程的基本概念、线程的基本状态及状态之间的关系?

线程,有时称为轻量级进程,是CPU使用的基本单元;它由线程ID、程序计数器、寄存器集合和堆栈组成。它与属于同一进程的其他线程共享其代码段、数据段和其他操作系统资源(如打开文件和信号)。

线程有四种状态:新生状态、可运行状态、被阻塞状态、死亡状态。状态之间的转换如下图所示:

 


第二题:线程与进程的区别?

1、 线程是进程的一部分,所以线程有的时候被称为是轻权进程或者轻量级进程。
2、 一个没有线程的进程是可以被看作单线程的,如果一个进程内拥有多个进程,进程的执行过程不是一条线(线程)的,而是多条线(线程)共同完成的。
3、 系统在运行的时候会为每个进程分配不同的内存区域,但是不会为线程分配内存(线程所使用的资源是它所属的进程的资源),线程组只能共享资源。那就是说,出了CPU之外(线程在运行的时候要占用CPU资源),计算机内部的软硬件资源的分配与线程无关,线程只能共享它所属进程的资源。
4、 与进程的控制表PCB相似,线程也有自己的控制表TCB,但是TCB中所保存的线程状态比PCB表中少多了。
5、 进程是系统所有资源分配时候的一个基本单位,拥有一个完整的虚拟空间地址,并不依赖线程而独立存在。

 

第三题:多线程有几种实现方法,都是什么?

 1. 继承 Thread 类
  2. 实现 Runnable 接口再 new Thread(YourRunnableOjbect) 

第四题:多线程同步和互斥有几种实现方法,都是什么?



线程间的同步方法大体可分为两类:用户模式和内核模式。顾名思义,内核模式就是指利用系统内核对象的单一性来进行同步,使用时需要切换内核态与用户态,而用户模式就是不需要切换到内核态,只在用户态完成操作。
用户模式下的方法有:原子操作(例如一个单一的全局变量),临界区。内核模式下的方法有:事件,信号量,互斥量。

 

第五题:多线程同步和互斥有何异同,在什么情况下分别使用他们?举例说明。

线程同步是指线程之间所具有的一种制约关系,一个线程的执行依赖另一个线程的消息,当它没有得到另一个线程的消息时应等待,直到消息到达时才被唤醒。

线程互斥是指对于共享的进程系统资源,在各单个线程访问时的排它性。当有若干个线程都要使用某一共享资源时,任何时刻最多只允许一个线程去使用,其它要使用该资源的线程必须等待,直到占用资源者释放该资源。线程互斥可以看成是一种特殊的线程同步(下文统称为同步)。

1


 

2、以下多线程对int型变量x的操作,哪几个不需要进行同步(D)
        A. x=y;      B. x++;    C. ++x;    D. x=1;

        详见:后面系列解析

3、多线程中栈与堆是公有的还是私有的 (C)

        A:栈公有, 堆私有

        B:栈公有,堆公有

        C:栈私有, 堆公有

        D:栈私有,堆私有

4、临界区(Critical Section)和互斥量(Mutex)

        两者都可以用于同一进程中不同子线程对资源的互斥访问。

        互斥量是内核对象,因此还可以用于不同进程中子线程对资源的互斥访问。

        互斥量可以很好的解决由于线程意外终止资源无法释放的问题。

5、一个全局变量tally,两个线程并发执行(代码段都是ThreadProc),问两个线程都结束后,tally取值范围。

        inttally = 0;//glable

        voidThreadProc()

        {

              for(inti = 1;i <= 50;i++)

                   tally += 1;

        }

        答:[50,100]

6、编写一个程序,开启3个线程,这3个线程的ID分别为ABC,每个线程将自己的ID在屏幕上打印10遍,要求输出结果必须按ABC的顺序显示;如:ABCABC.依次递推。

        思路:用信号量进行各个子线程之间的互斥,创建3个信号量A、B、C。初始时A的资源数为1,B、C的资源数为0,访问A之后,将B的资源数加1,访问B之后将C的资源数加1,访问C之后将A的资源数加1。创建3个子线程顺序访问资源A、B、C。

  1. #include "stdafx.h"  
  2. #include "stdio.h"  
  3. #include "stdlib.h"  
  4. #include <iostream>  
  5. #include <string>  
  6. #include <stack>  
  7. #include <windows.h>  
  8. #include <process.h>  
  9. using namespace std;  
  10.   
  11. const int THREAD_NUM = 10;  
  12. HANDLE            ga,gb,gc;  
  13.   
  14. unsigned int __stdcall FunA(void *pPM)  
  15. {  
  16.     Sleep(50);//some work should to do  
  17.     printf("A\n");  
  18.     ReleaseSemaphore(gb, 1, NULL);//递增信号量B的资源数    
  19.   
  20.     return 0;  
  21. }  
  22.   
  23. unsigned int __stdcall FunB(void *pPM)  
  24. {     
  25.     Sleep(50);//some work should to do  
  26.     printf("B\n");  
  27.     ReleaseSemaphore(gc, 1, NULL);//递增信号量C的资源数    
  28.   
  29.     return 0;  
  30. }  
  31.   
  32. unsigned int __stdcall FunC(void *pPM)  
  33. {  
  34.     Sleep(50);//some work should to do  
  35.     printf("C\n");  
  36.     ReleaseSemaphore(ga, 1, NULL);//递增信号量A的资源数    
  37.   
  38.     return 0;  
  39. }  
  40.   
  41. int main()  
  42. {  
  43.     //初始化信号量  
  44.     ga = CreateSemaphore(NULL, 1, 1, NULL);//当前1个资源,最大允许1个同时访问  
  45.     gb = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源,最大允许1个同时访问  
  46.     gc = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源,最大允许1个同时访问  
  47.       
  48.     HANDLE  handle[THREAD_NUM];   
  49.     int i = 0;  
  50.     while (i < THREAD_NUM)   
  51.     {  
  52.         WaitForSingleObject(ga, INFINITE);  //等待信号量A>0  
  53.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunA, &i, 0, NULL);  
  54.         WaitForSingleObject(gb, INFINITE);  //等待信号量B>0  
  55.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunB, &i, 0, NULL);  
  56.         WaitForSingleObject(gc, INFINITE);  //等待信号量C>0  
  57.         handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunC, &i, 0, NULL);  
  58.           
  59.         ++i;  
  60.     }  
  61.     WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);  
  62.       
  63.     //销毁信号量  
  64.     CloseHandle(ga);  
  65.     CloseHandle(gb);  
  66.     CloseHandle(gc);  
  67.     for (i = 0; i < THREAD_NUM; i++)  
  68.         CloseHandle(handle[i]);  
  69.     return 0;  
  70. }  
  1. #include "stdafx.h"
  2. #include "stdio.h"
  3. #include "stdlib.h"
  4. #include <iostream>
  5. #include <string>
  6. #include <stack>
  7. #include <windows.h>
  8. #include <process.h>
  9. using namespace std;
  10. const int THREAD_NUM = 10;
  11. HANDLE ga,gb,gc;
  12. unsigned int __stdcall FunA(void *pPM)
  13. {
  14. Sleep(50);//some work should to do
  15. printf("A\n");
  16. ReleaseSemaphore(gb, 1, NULL);//递增信号量B的资源数
  17. return 0;
  18. }
  19. unsigned int __stdcall FunB(void *pPM)
  20. {
  21. Sleep(50);//some work should to do
  22. printf("B\n");
  23. ReleaseSemaphore(gc, 1, NULL);//递增信号量C的资源数
  24. return 0;
  25. }
  26. unsigned int __stdcall FunC(void *pPM)
  27. {
  28. Sleep(50);//some work should to do
  29. printf("C\n");
  30. ReleaseSemaphore(ga, 1, NULL);//递增信号量A的资源数
  31. return 0;
  32. }
  33. int main()
  34. {
  35. //初始化信号量
  36. ga = CreateSemaphore(NULL, 1, 1, NULL);//当前1个资源,最大允许1个同时访问
  37. gb = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源,最大允许1个同时访问
  38. gc = CreateSemaphore(NULL, 0, 1, NULL);//当前0个资源,最大允许1个同时访问
  39. HANDLE handle[THREAD_NUM];
  40. int i = 0;
  41. while (i < THREAD_NUM)
  42. {
  43. WaitForSingleObject(ga, INFINITE); //等待信号量A>0
  44. handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunA, &i, 0, NULL);
  45. WaitForSingleObject(gb, INFINITE); //等待信号量B>0
  46. handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunB, &i, 0, NULL);
  47. WaitForSingleObject(gc, INFINITE); //等待信号量C>0
  48. handle[i] = (HANDLE)_beginthreadex(NULL, 0, FunC, &i, 0, NULL);
  49. ++i;
  50. }
  51. WaitForMultipleObjects(THREAD_NUM, handle, TRUE, INFINITE);
  52. //销毁信号量
  53. CloseHandle(ga);
  54. CloseHandle(gb);
  55. CloseHandle(gc);
  56. for (i = 0; i < THREAD_NUM; i++)
  57. CloseHandle(handle[i]);
  58. return 0;
  59. }

7、生产者消费者问题:有一个生产者在生产产品,这些产品将提供给若干个消费者去消费,为了使生产者和消费者能并发执行,在两者之间设置一个有多个缓冲区的缓冲池,生产者将它生产的产品放入一个缓冲区中,消费者可以从缓冲区中取走产品进行消费,所有生产者和消费者都是异步方式运行的,但它们必须保持同步,即不允许消费者到一个空的缓冲区中取产品,也不允许生产者向一个已经装满产品且尚未被取走的缓冲区中投放产品。

        分析:假设1个生产者,2个消费者,缓冲区大小为4。

第一.从缓冲区取出产品和向缓冲区投放产品必须是互斥进行的。可以用关键段互斥量来完成。

第二.生产者要等待缓冲区为空,这样才可以投放产品,消费者要等待缓冲区不为空,这样才可以取出产品进行消费。并且由于有二个等待过程,所以要用二个事件或信号量来控制。

代码如下:

  1. //1生产者 2消费者 4缓冲区  
  2. #include "stdafx.h"  
  3. #include "stdio.h"  
  4. #include "stdlib.h"  
  5. #include <iostream>  
  6. #include <string>  
  7. #include <stack>  
  8. #include <windows.h>  
  9. #include <process.h>  
  10. using namespace std;  
  11.   
  12. //设置控制台输出颜色  
  13. BOOL SetConsoleColor(WORD wAttributes)  
  14. {  
  15.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);  
  16.     if (hConsole == INVALID_HANDLE_VALUE)  
  17.         return FALSE;  
  18.       
  19.     return SetConsoleTextAttribute(hConsole, wAttributes);  
  20. }  
  21.   
  22. const int END_PRODUCE_NUMBER = 8;   //生产产品个数  
  23. const int BUFFER_SIZE = 4;          //缓冲区个数  
  24. int g_Buffer[BUFFER_SIZE];          //缓冲池  
  25. int g_i, g_j;  
  26. CRITICAL_SECTION g_cs;              //信号量与关键段  
  27. HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;  
  28.   
  29. //生产者线程函数  
  30. unsigned int __stdcall ProducerThreadFun(PVOID pM)  
  31. {  
  32.     for (int i = 1; i <= END_PRODUCE_NUMBER; i++)  
  33.     {  
  34.         //等待有空的缓冲区出现  
  35.         WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);  
  36.   
  37.         //互斥的访问缓冲区  
  38.         EnterCriticalSection(&g_cs);  
  39.         g_Buffer[g_i] = i;  
  40.         printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);  
  41.         g_i = (g_i + 1) % BUFFER_SIZE;  
  42.         LeaveCriticalSection(&g_cs);  
  43.   
  44.         //通知消费者有新数据了  
  45.         ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);  
  46.     }  
  47.     printf("生产者完成任务,线程结束运行\n");  
  48.     return 0;  
  49. }  
  50.   
  51. //消费者线程函数  
  52. unsigned int __stdcall ConsumerThreadFun(PVOID pM)  
  53. {  
  54.     while (true)  
  55.     {  
  56.         //等待非空的缓冲区出现  
  57.         WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);  
  58.           
  59.         //互斥的访问缓冲区  
  60.         EnterCriticalSection(&g_cs);  
  61.         SetConsoleColor(FOREGROUND_GREEN);  
  62.         printf("  编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);  
  63.         SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  64.         if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志  
  65.         {  
  66.             LeaveCriticalSection(&g_cs);  
  67.             //通知其它消费者有新数据了(结束标志)  
  68.             ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);  
  69.             break;  
  70.         }  
  71.         g_j = (g_j + 1) % BUFFER_SIZE;  
  72.         LeaveCriticalSection(&g_cs);  
  73.   
  74.         Sleep(50); //some other work to do  
  75.   
  76.         ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);  
  77.     }  
  78.     SetConsoleColor(FOREGROUND_GREEN);  
  79.     printf("  编号为%d的消费者收到通知,线程结束运行\n", GetCurrentThreadId());  
  80.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  81.     return 0;  
  82. }  
  83.   
  84. int main()  
  85. {  
  86.     InitializeCriticalSection(&g_cs);  
  87.     //初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.  
  88.     g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);  
  89.     g_hSemaphoreBufferFull  = CreateSemaphore(NULL, 0, 4, NULL);  
  90.     g_i = 0;  
  91.     g_j = 0;  
  92.     memset(g_Buffer, 0, sizeof(g_Buffer));  
  93.   
  94.     const int THREADNUM = 3;  
  95.     HANDLE hThread[THREADNUM];  
  96.     //生产者线程  
  97.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);  
  98.     //消费者线程  
  99.     hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);  
  100.     hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);  
  101.     WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);  
  102.   
  103.     for (int i = 0; i < THREADNUM; i++)        
  104.         CloseHandle(hThread[i]);  
  105.   
  106.     //销毁信号量和关键段  
  107.     CloseHandle(g_hSemaphoreBufferEmpty);  
  108.     CloseHandle(g_hSemaphoreBufferFull);  
  109.     DeleteCriticalSection(&g_cs);  
  110.     return 0;  
  111. }  
  1. //1生产者 2消费者 4缓冲区
  2. #include "stdafx.h"
  3. #include "stdio.h"
  4. #include "stdlib.h"
  5. #include <iostream>
  6. #include <string>
  7. #include <stack>
  8. #include <windows.h>
  9. #include <process.h>
  10. using namespace std;
  11. //设置控制台输出颜色
  12. BOOL SetConsoleColor(WORD wAttributes)
  13. {
  14. HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
  15. if (hConsole == INVALID_HANDLE_VALUE)
  16. return FALSE;
  17. return SetConsoleTextAttribute(hConsole, wAttributes);
  18. }
  19. const int END_PRODUCE_NUMBER = 8; //生产产品个数
  20. const int BUFFER_SIZE = 4; //缓冲区个数
  21. int g_Buffer[BUFFER_SIZE]; //缓冲池
  22. int g_i, g_j;
  23. CRITICAL_SECTION g_cs; //信号量与关键段
  24. HANDLE g_hSemaphoreBufferEmpty, g_hSemaphoreBufferFull;
  25. //生产者线程函数
  26. unsigned int __stdcall ProducerThreadFun(PVOID pM)
  27. {
  28. for (int i = 1; i <= END_PRODUCE_NUMBER; i++)
  29. {
  30. //等待有空的缓冲区出现
  31. WaitForSingleObject(g_hSemaphoreBufferEmpty, INFINITE);
  32. //互斥的访问缓冲区
  33. EnterCriticalSection(&g_cs);
  34. g_Buffer[g_i] = i;
  35. printf("生产者在缓冲池第%d个缓冲区中投放数据%d\n", g_i, g_Buffer[g_i]);
  36. g_i = (g_i + 1) % BUFFER_SIZE;
  37. LeaveCriticalSection(&g_cs);
  38. //通知消费者有新数据了
  39. ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  40. }
  41. printf("生产者完成任务,线程结束运行\n");
  42. return 0;
  43. }
  44. //消费者线程函数
  45. unsigned int __stdcall ConsumerThreadFun(PVOID pM)
  46. {
  47. while (true)
  48. {
  49. //等待非空的缓冲区出现
  50. WaitForSingleObject(g_hSemaphoreBufferFull, INFINITE);
  51. //互斥的访问缓冲区
  52. EnterCriticalSection(&g_cs);
  53. SetConsoleColor(FOREGROUND_GREEN);
  54. printf(" 编号为%d的消费者从缓冲池中第%d个缓冲区取出数据%d\n", GetCurrentThreadId(), g_j, g_Buffer[g_j]);
  55. SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  56. if (g_Buffer[g_j] == END_PRODUCE_NUMBER)//结束标志
  57. {
  58. LeaveCriticalSection(&g_cs);
  59. //通知其它消费者有新数据了(结束标志)
  60. ReleaseSemaphore(g_hSemaphoreBufferFull, 1, NULL);
  61. break;
  62. }
  63. g_j = (g_j + 1) % BUFFER_SIZE;
  64. LeaveCriticalSection(&g_cs);
  65. Sleep(50); //some other work to do
  66. ReleaseSemaphore(g_hSemaphoreBufferEmpty, 1, NULL);
  67. }
  68. SetConsoleColor(FOREGROUND_GREEN);
  69. printf(" 编号为%d的消费者收到通知,线程结束运行\n", GetCurrentThreadId());
  70. SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);
  71. return 0;
  72. }
  73. int main()
  74. {
  75. InitializeCriticalSection(&g_cs);
  76. //初始化信号量,一个记录有产品的缓冲区个数,另一个记录空缓冲区个数.
  77. g_hSemaphoreBufferEmpty = CreateSemaphore(NULL, 4, 4, NULL);
  78. g_hSemaphoreBufferFull = CreateSemaphore(NULL, 0, 4, NULL);
  79. g_i = 0;
  80. g_j = 0;
  81. memset(g_Buffer, 0, sizeof(g_Buffer));
  82. const int THREADNUM = 3;
  83. HANDLE hThread[THREADNUM];
  84. //生产者线程
  85. hThread[0] = (HANDLE)_beginthreadex(NULL, 0, ProducerThreadFun, NULL, 0, NULL);
  86. //消费者线程
  87. hThread[1] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  88. hThread[2] = (HANDLE)_beginthreadex(NULL, 0, ConsumerThreadFun, NULL, 0, NULL);
  89. WaitForMultipleObjects(THREADNUM, hThread, TRUE, INFINITE);
  90. for (int i = 0; i < THREADNUM; i++)
  91. CloseHandle(hThread[i]);
  92. //销毁信号量和关键段
  93. CloseHandle(g_hSemaphoreBufferEmpty);
  94. CloseHandle(g_hSemaphoreBufferFull);
  95. DeleteCriticalSection(&g_cs);
  96. return 0;
  97. }

8、读者写者问题:这也是一个非常经典的多线程题目,题目大意如下:有一个写者很多读者,多个读者可以同时读文件,但写者在写文件时不允许有读者在读文件,同样有读者读时写者也不能写。

    分析:首先来找找哪些是属于“等待”情况。

第一、写者要等到没有读者时才能去写文件。

第二、所有读者要等待写者完成写文件后才能去读文件。

找完“等待”情况后,再看看有没有要互斥访问的资源。由于只有一个写者而读者们是可以共享的读文件,所以按题目要求并没有需要互斥访问的资源。代码如下:

  1. #include "stdafx.h"  
  2. #include "stdio.h"  
  3. #include "stdlib.h"  
  4. #include <iostream>  
  5. #include <string>  
  6. #include <stack>  
  7. #include <windows.h>  
  8. #include <process.h>  
  9. using namespace std;  
  10.   
  11. //读者与写者问题  
  12. #include <stdio.h>  
  13. #include <process.h>  
  14. #include <windows.h>  
  15. //设置控制台输出颜色  
  16. BOOL SetConsoleColor(WORD wAttributes)  
  17. {  
  18.     HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);  
  19.     if (hConsole == INVALID_HANDLE_VALUE)  
  20.         return FALSE;  
  21.       
  22.     return SetConsoleTextAttribute(hConsole, wAttributes);  
  23. }  
  24. const int READER_NUM = 5;  //读者个数  
  25. //关键段和事件  
  26. CRITICAL_SECTION g_cs, g_cs_writer_count;  
  27. HANDLE g_hEventWriter, g_hEventNoReader;  
  28. int g_nReaderCount;  
  29. //读者线程输出函数(变参函数的实现)  
  30. void ReaderPrintf(char *pszFormat, ...)  
  31. {  
  32.     va_list   pArgList;  
  33.       
  34.     va_start(pArgList, pszFormat);  
  35.     EnterCriticalSection(&g_cs);  
  36.     vfprintf(stdout, pszFormat, pArgList);  
  37.     LeaveCriticalSection(&g_cs);  
  38.     va_end(pArgList);  
  39. }  
  40. //读者线程函数  
  41. unsigned int __stdcall ReaderThreadFun(PVOID pM)  
  42. {  
  43.     ReaderPrintf("     编号为%d的读者进入等待中...\n", GetCurrentThreadId());  
  44.     //等待写者完成  
  45.     WaitForSingleObject(g_hEventWriter, INFINITE);  
  46.   
  47.     //读者个数增加  
  48.     EnterCriticalSection(&g_cs_writer_count);  
  49.     g_nReaderCount++;  
  50.     if (g_nReaderCount == 1)  
  51.         ResetEvent(g_hEventNoReader);  
  52.     LeaveCriticalSection(&g_cs_writer_count);  
  53.   
  54.     //读取文件  
  55.     ReaderPrintf("编号为%d的读者开始读取文件...\n", GetCurrentThreadId());  
  56.   
  57.     Sleep(rand() % 100);  
  58.   
  59.     //结束阅读,读者个数减小,空位增加  
  60.     ReaderPrintf(" 编号为%d的读者结束读取文件\n", GetCurrentThreadId());  
  61.   
  62.     //读者个数减少  
  63.     EnterCriticalSection(&g_cs_writer_count);  
  64.     g_nReaderCount--;  
  65.     if (g_nReaderCount == 0)  
  66.         SetEvent(g_hEventNoReader);  
  67.     LeaveCriticalSection(&g_cs_writer_count);  
  68.   
  69.     return 0;  
  70. }  
  71. //写者线程输出函数  
  72. void WriterPrintf(char *pszStr)  
  73. {  
  74.     EnterCriticalSection(&g_cs);  
  75.     SetConsoleColor(FOREGROUND_GREEN);  
  76.     printf("     %s\n", pszStr);  
  77.     SetConsoleColor(FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE);  
  78.     LeaveCriticalSection(&g_cs);  
  79. }  
  80. //写者线程函数  
  81. unsigned int __stdcall WriterThreadFun(PVOID pM)  
  82. {  
  83.     WriterPrintf("写者线程进入等待中...");  
  84.     //等待读文件的读者为零  
  85.     WaitForSingleObject(g_hEventNoReader, INFINITE);  
  86.     //标记写者正在写文件  
  87.     ResetEvent(g_hEventWriter);  
  88.           
  89.     //写文件  
  90.     WriterPrintf("  写者开始写文件.....");  
  91.     Sleep(rand() % 100);  
  92.     WriterPrintf("  写者结束写文件");  
  93.   
  94.     //标记写者结束写文件  
  95.     SetEvent(g_hEventWriter);  
  96.     return 0;  
  97. }  
  98.   
  99. int main()  
  100. {  
  101.     printf("  读者写者问题\n");  
  102.     printf(" -- by MoreWindows( http://blog.csdn.net/MoreWindows ) --\n\n");  
  103.   
  104.     //初始化事件和信号量  
  105.     InitializeCriticalSection(&g_cs);  
  106.     InitializeCriticalSection(&g_cs_writer_count);  
  107.   
  108.     //手动置位,初始已触发  
  109.     g_hEventWriter = CreateEvent(NULL, TRUE, TRUE, NULL);  
  110.     g_hEventNoReader  = CreateEvent(NULL, FALSE, TRUE, NULL);  
  111.     g_nReaderCount = 0;  
  112.   
  113.     int i;  
  114.     HANDLE hThread[READER_NUM + 1];  
  115.     //先启动二个读者线程  
  116.     for (i = 1; i <= 2; i++)  
  117.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  118.     //启动写者线程  
  119.     hThread[0] = (HANDLE)_beginthreadex(NULL, 0, WriterThreadFun, NULL, 0, NULL);  
  120.     Sleep(50);  
  121.     //最后启动其它读者结程  
  122.     for ( ; i <= READER_NUM; i++)  
  123.         hThread[i] = (HANDLE)_beginthreadex(NULL, 0, ReaderThreadFun, NULL, 0, NULL);  
  124.     WaitForMultipleObjects(READER_NUM + 1, hThread, TRUE, INFINITE);  
  125.     for (i = 0; i < READER_NUM + 1; i++)  
  126.         CloseHandle(hThread[i]);  
  127.   
  128.     //销毁事件和信号量  
  129.     CloseHandle(g_hEventWriter);  
  130.     CloseHandle(g_hEventNoReader);  
  131.     DeleteCriticalSection(&g_cs);  
  132.     DeleteCriticalSection(&g_cs_writer_count);  
  133.     return 0;  
  134. }  

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/天景科技苑/article/detail/1014231
推荐阅读
相关标签
  

闽ICP备14008679号