Go语言视频零基础入门到精通

javalearner

哲学家进餐问题是一个多线程运用的经典例子，涉及到线程同步/互斥，临界区访问问题以及一个避免死锁的解决方法。

      有五个哲学家绕着圆桌坐，每个哲学家面前有一盘面，两人之间有一支筷子，这样每个哲学家左右各有一支筷子。

    哲学家有2个状态，思考或者拿起筷子吃饭。如果哲学家拿到一只筷子，不能吃饭，直到拿到2只才能吃饭，并且一次只能拿起身边的一支筷子。一旦拿起便不会放下筷子直到把饭吃完，此时才把这双筷子放回原处。

    如果，很不幸地，每个哲学家拿起他或她左边的筷子，那么就没有人可以吃到饭了。这就会造成死锁了。。这是需要坚决杜绝的，正如操作系统的死锁问题。
                                                                                      
代码如下：
  
  

1. import java.util.Random;
   
2. public class DiningPhils
   
3. {
   
4. public static void main(String[] args)
   
5. {
   
6.   int n = 10;
   
7.   if( n < 1)
   
8.   {
   
9.    System.err.println( "DiningPils <# of philosophers>" );
   
10.    System.exit(-1);
    
11.   }
    
12.   DiningPhils self = new DiningPhils();
    
13.   self.init(n);
    
14. }
    
15. 
    
16. public int getCount()
    
17. {
    
18.   return n;
    
19. }
    
20. public void setChopstick( int i, boolean v)
    
21. {
    
22.   chops[ i ] = v;
    
23. }
    
24. public boolean getChopstick( int i )
    
25. {
    
26.   return chops[i];
    
27. }
    
28. 
    
29. private void init( final int N)
    
30. {
    
31.   r = new Random();
    
32.   n = ( N < 0 || N > maxPhils ) ? maxPhils : N;
    
33.   chops = new boolean[n];
    
34.   phils = new Philosopher[n];
    
35.   initPhils();
    
36.   dumpStatus();
    
37. }
    
38. private void initPhils()
    
39. {
    
40.   for( int i = 0; i< n; i++ )
    
41.   {
    
42.    phils[i] = new Philosopher( this, i );
    
43.    phils[i].setTimeSlice( generateTimeSlice());
    
44.    phils[i].setPriority( Thread.NORM_PRIORITY - 1);
    
45. /**哲学家进程降低一级，使所有哲学家进程
    
46. *全部初始化完毕前不会有哲学家进程抢占主线程*/
    
47.   }
    
48.   while( moreToStart() )
    
49.   {
    
50.    int i = Math.abs( r.nextInt()) % n;
    
51.    if( !phils[i].isAlive())
    
52.    {
    
53.     System.out.println( " ### Philosopher " +
    
54.       String.valueOf( i ) + " started.");
    
55.     phils[i].start();
    
56.    }
    
57.   }
    
58.   System.out.println( "
59. Philosophers              Chopsticks"
    
60.     + "
61. (1 = eating, 0 = thinking)  (1 = taken, 0 = free)");
    
62. }
    
63. public int generateTimeSlice()
    
64. {
    
65.   int ts = Math.abs(r.nextInt()) %  (maxEat + 1);
    
66.   if( ts == 0 )
    
67.    ts = minEat;
    
68.   return ts;
    
69. }
    
70. public void dumpStatus()
    
71. {
    
72.   for( int i = 0; i < n; i++)
    
73.    System.out.print(phils[i].getEat() ? 1 : 0);
    
74.   for( int i = n; i < maxPhils + 4; i++ )
    
75.    System.out.print(" ");
    
76.   for( int i = 0; i < n; i++)
    
77.    System.out.print(chops[i]? 1:0);
    
78.   System.out.println();
    
79. }
    
80. 
    
81. private boolean moreToStart()
    
82. {
    
83.   for( int i = 0; i < phils.length; i++ )
    
84.   {
    
85.    if( !phils[i].isAlive())
    
86.     return true;
    
87.   }
    
88.   return false;
    
89. }
    
90. private int n;
    
91. private Philosopher[] phils;
    
92. private boolean[] chops;
    
93. private Random r;
    
94. private static final int maxPhils = 24;  //最多哲学家数
    
95. private static final int maxEat = 4;   //最多进餐时间
    
96. private static final int minEat = 1;   //最少进餐时间
    
97. }
    
98. class Philosopher extends Thread
    
99. {
    
100. public Philosopher( DiningPhils HOST , int i )
     
101. {
     
102.   host = HOST;
     
103.   index = i;
     
104. }
     
105. public void setTimeSlice( int TS )
     
106. {
     
107.   ts = TS;
     
108. }
     
109. public void setLeftChopstick( boolean flag )
     
110. {
     
111.   host.setChopstick(index, flag);
     
112. }
     
113. public void setRightChopstick( boolean flag )
     
114. {
     
115.   host.setChopstick((index + 1)% host.getCount() , flag);
     
116. }
     
117. private void releaseChopsticks()
     
118. {
     
119.   setLeftChopstick(false);
     
120.   setRightChopstick(false);
     
121. }
     
122. public boolean chopsticksFree()
     
123. {
     
124.   return !host.getChopstick(index) &&
     
125.   !host.getChopstick((index+1)%host.getCount());
     
126. }
     
127. 
     
128. public void run()
     
129. {
     
130.   while(true)
     
131.   {
     
132.    grabChopsticks();
     
133.    eat();
     
134.    think();
     
135.   }
     
136. }
     
137. private synchronized void grabChopsticks() /**临界区函数，确保哲学家在没有筷子或筷子不够时思考，满足条件后才就餐*/
     
138. {
     
139.   while( !chopsticksFree())
     
140.   {
     
141.    try
     
142.    {
     
143.     wait();
     
144.    }
     
145.    catch( InterruptedException e){}
     
146.   }
     
147.   takeChopsticks();
     
148.   notifyAll();
     
149. }
     
150. private void takeChopsticks()
     
151. {
     
152.   setLeftChopstick( true );
     
153.   setRightChopstick( true );
     
154.   setEat(true);
     
155.   host.dumpStatus();
     
156. }
     
157. private void eat()
     
158. {
     
159.   pause();
     
160.   setEat( false );
     
161.   releaseChopsticks();
     
162. }
     
163. private void think()
     
164. {
     
165.   pause();
     
166. }
     
167. private void pause()
     
168. {
     
169.   setTimeSlice( host.generateTimeSlice());
     
170.   try
     
171.   {
     
172.    sleep(ts*1000);
     
173.   }
     
174.   catch( InterruptedException e){}
     
175. }
     
176. private void setEat(boolean v)
     
177. {
     
178.   isEating = v;
     
179. }
     
180. public boolean getEat()
     
181. {
     
182.   return isEating;
     
183. }
     
184. private DiningPhils host;
     
185. private boolean isEating;
     
186. private int index;
     
187. private int ts;
     
188. }
     

复制代码

   
     
     
      
      

        
      

        
      
     
   

  


源码下载：http://file.javaxxz.com/2014/11/4/000146109.zip