多线程_哲学家问题

哲学家进餐问题

在多线程中如何避免死锁。

 

问题描述：有五位哲学家围绕着餐桌坐，每一位哲学家要么思考

要么等待，要么吃饭。为了吃饭，哲学家必须拿起两支筷子（分

别放于左右两端）不幸的是，筷子的数量和哲学家相等，所以每

只筷子必须由两位哲学家共享

一、使用数组来跟踪一个哲学家的的状态：吃饭，思考或是试图拿起筷子，规定一个哲学家只有在两个邻居都不再进餐时才允许转移到进餐状态。这种方法可以使系统获得最大的并行度，即最多允许两个哲学家同时进餐。 
二、给每个哲学家编号，规定奇数号的哲学家先拿他的左筷子，然后再去拿他的右筷子；而偶数号的哲学家则相反。这样总可以保证至少有一个哲学家可以进餐。

一般都使用第二种方法，高效而简单。

普通解法，会死锁，不过还得等好一会。电脑速度这么快，也差不多等了五分钟以后才死锁。但是不管等多久死锁，理论上讲，死锁是早晚的事，所以还是防着点好。

1. #include <windows.h>  
2. #include <iostream>  
3. #include <process.h>  
4. #include <cstdlib>  
5. #include <ctime>  
6.   
7. using namespace std;  
8.  DWORD WINAPI philosopher(LPVOID lpParameter);  
9.   
10. void thinking(int);  
11. void eating(int);  
12. void waiting(int);  
13.   
14. void print(int ,const char *);  
15.   
16. //全局变量  
17. CRITICAL_SECTION crout;//这个变量用来保证输出时不会竞争  
18.   
19. CRITICAL_SECTION fork[5];//定义五个临界变量，代表五更筷子  
20.   
21. int main(int argc,char *argv[])  
22. {  
23.     HANDLE hthread[5];  
24.     int i;  
25.     int arg[5];  
26.     int count = 5;  
27.     unsigned long retval;  
28.   
29.   
30.     InitializeCriticalSection(&crout);  
31.     //初始化临界变量  
32.     for(i=0;i<5;i++)  
33.     {  
34.         InitializeCriticalSection(fork + i);  
35.     }  
36.     //创建五个哲学家  
37.     for(i = 0; i<5;i++)  
38.     {  
39.         arg[i] = i;  
40.         hthread[i] = CreateThread(NULL, 0, philosopher, (void*)(arg+i), 0, NULL);  
41.         if( hthread[i] == INVALID_HANDLE_VALUE)//如果线程创建失败返回-1  
42.         {  
43.             cerr << "error while create thread " << i <<endl;  
44.             cerr << "error code : "<< GetLastError() <<endl;  
45.         }  
46.     }  
47.     //等待所有线程结束  
48.     retval = WaitForMultipleObjects(5,hthread,true,INFINITE);//等待多个线程  
49.     if(retval == WAIT_FAILED)  
50.     {  
51.         cerr<< "wait error,error code: "<<GetLastError()<<endl;  
52.     }  
53.     for(i = 0; i<5;i++)  
54.     {  
55.         if(CloseHandle(hthread[i]) == false)//关闭句柄  
56.         {  
57.             cerr << "error while close thread " <<i<<endl;  
58.             cerr << "error code: "<<GetLastError()<<endl;  
59.         }  
60.     }  
61.     return 0;  
62. }  
63.   
64.   
65. DWORD WINAPI philosopher(LPVOID lpParameter)  
66. {  
67.     int n = ((int *)lpParameter)[0];  
68.   
69.     print(n," is in!");  
70.   
71.     //srand(time(NULL));  
72.     while(true)  
73.     {  
74.         thinking(n);  
75.         waiting(n);  
76.         eating(n);  
77.     }  
78.   
79.     print(n," is out!");  
80.   
81.     return n;  
82. }  
83.   
84. void thinking(int k)  
85. {  
86.     print(k," is thinking...");  
87.   
88.     Sleep(1);  
89.     //Sleep((rand() %100) *5);  
90. }  
91.   
92. void eating(int k)  
93. {  
94.     print(k," is eating...");  
95.     //Sleep((rand()%100) *5);  
96.     Sleep(1);  
97.     LeaveCriticalSection(fork + (k+1)%5);//放下右边的筷子  
98.     //print(k," give left");  
99.     LeaveCriticalSection(fork + k);//放下左边的筷子  
100.     //print(k," give right");  
101. }  
102.   
103. void waiting(int k)  
104. {  
105.     print(k," is waiting...");  
106.     Sleep(1);  
107.     EnterCriticalSection(fork + k);//获得左边的筷子  
108.     //print(k," take left");  
109.     EnterCriticalSection(fork + (k + 1)%5);//获得右边的筷子  
110.     //print(k," take right");  
111. }  
112.   
113. void print(int who,const char *str)  
114. {  
115.     EnterCriticalSection(&crout);  
116.     cout<<"process "<<who<<str<<endl;  
117.     LeaveCriticalSection(&crout);  
118. }  

可见，死锁的时候Process0——4都是waiting...状态

略加修改就不会产生死锁了。

1. void waiting(int k)  
2. {  
3.     print(k," is waiting...");  
4.     Sleep(1);  
5.     if ( k % 2 == 0)  
6.     {  
7.         EnterCriticalSection(fork + k);//获得左边的筷子  
8.         EnterCriticalSection(fork + (k + 1)%5);//获得右边的筷子  
9.     }  
10.     else  
11.     {  
12.         EnterCriticalSection(fork + (k + 1)%5);//获得右边的筷子  
13.         EnterCriticalSection(fork + k);//获得左边的筷子  
14.     }  
15. }