多线程模型及示例

信号量 是E. W.Dijkstra在l965年提出的一种方法，它使用一个整型变量来累计唤醒次数，以供以后使用。在他的建议中引入一个新的变号类型，称作信号量(semapore )。一个信号量的值可以为0,表示没有积累下来的唤醒操作;或者为正值，表示有一个或多个被积累下来的唤醒操作。
      Dijkstra建议设两种操作:Down和Up。对一信号量执行Down操作是检查其值是否大于0;若是则将其值减1(即用掉一个保存的唤醒信号)并继续。若值为0,则进程将睡眠，而且此时Down操作并未结束。检查数值，改变数值以及可能发生的睡眠操作均作为一个单一的、不可分割的原子操作(atomic action)完成。即保证一旦一个信号量操作开始，则在操作完成或阻塞之前别的进程均不允许访问该信号量。这种原子性对于解决同步间题和避免竞争条件是非常重要的。
      Up操作递增信号量的值。如果一个或多个进程在该信号量上睡眠，无法完成一个先前的Down操作、则由系统选择其中的一个(例如，随机挑选)并允许其完成它的Down操作。于是，对一个有进程在其上睡眠的信号量执行一次Up操作之后，该信号量的值仍旧是0.但在其上睡眠的进程却少了一个。递增信号量的值和唤醒一个进程同样也是不可分割的。不会有进程因执行Up而阻塞。

   
      JDK的并发包就给我提供了一个类似的信号量类——Semaphore ，其中的acquire()和release()方法就相当于Down和Up操作，这两个方法的特殊之处在于对Semaphore对象的操作都是原子操作，由操作系统底层来支持。下面我们讲的四种经典线程同步问题，都是使用了Java编码。

 

 

1、生产者-消费者问题 
   
   由一个大小固定的仓库，生产者将生产的产品放入仓库，如果仓库满，则生成者被阻塞。消费者将仓库中的产品拿出来消耗，如果仓库空，则消费者被阻塞。

Java代码   

1. import java.util.concurrent.Semaphore;  
2.   
3. class Signs{  
4.       static Semaphore empty=new Semaphore(10); //信号量：记录仓库空的位置  
5.     static Semaphore full=new Semaphore(0);   //信号量：记录仓库满的位置  
6.     static Semaphore mutex=new Semaphore(1);  //临界区互斥访问信号量(二进制信号量)，相当于互斥锁。  
7. }  
8. class Producer implements Runnable{  
9.       
10.       public void run(){  
11.            try {  
12.                   while(true){  
13.                          Signs.empty.acquire(); //递减仓库空信号量  
14.           Signs.mutex.acquire(); //进入临界区  
15.           System.out.println("生成一个产品放入仓库");  
16.              Signs.mutex.release(); //离开临界区  
17.           Signs.full.release();  //递增仓库满信号量  
18.           Thread.currentThread().sleep(100);  
19.       }  
20.            } catch (InterruptedException e) {  
21.         e.printStackTrace();  
22.            }  
23.       }  
24. }  
25. class Consumer implements Runnable{  
26.        public void run(){  
27.             try {  
28.                  while(true){  
29.            Signs.full.acquire(); //递减仓库满信号量  
30.          Signs.mutex.acquire();  
31.            System.out.println("从仓库拿出一个产品消费");  
32.            Signs.mutex.release();  
33.            Signs.empty.release(); //递增仓库空信号量  
34.          Thread.currentThread().sleep(1000);  
35.       }  
36.             } catch (InterruptedException e) {  
37.        e.printStackTrace();  
38.             }  
39.        }  
40.       
41. }  
42. public class Test{  
43.   
44.     public static void main(String[] args) {  
45.         new Thread(new Producer()).start();  
46.         new Thread(new Consumer()).start();  
47.     }  
48. }  

 

 

2、哲学家进餐问题

 

      在1965年，Dijkstra提出并解决了一个他称之为哲学家进餐的同步问题。从那时起，每个发明新的同步原语的人都希望通过解决哲学家进餐间题来展示其同步原语的精妙之处。这个问题可以简单地描述：五个哲学家围坐在一张圆桌周围，每个哲学家面前都有一碟通心面，由于面条很滑，所以要两把叉子才能夹住。相邻两个碟子之间有一把叉子。
      哲学家的生活包括两种活动:即吃饭和思考。当一个哲学家觉得饿时，他就试图去取他左边和右边的叉子。如果成功地获得两把叉子，他就开始吃饭，吃完以后放下叉子继续思考。

Java代码   

1. import java.util.concurrent.Semaphore;  
2.   
3. class Signs{  
4.     final static int THINKING=0; //哲学家的状态THINGING  
5.     final static int EATING=1; //哲学家的状态EATING  
6.     static int[] status=new int[5]; //哲学家的状态，默认都是THINGING  
7.     static Semaphore[] s=null; //信号量：记录哲学家是否可以进餐，不能进餐则堵塞  
8.     static Semaphore mutex=new Semaphore(1); //临界区互斥访问信号量(二进制信号量)，相当于互斥锁  
9.       
10.     //初始化每个哲学家的进餐信号量，默认值都不能进餐  
11.     static{  
12.         s=new Semaphore[5];  
13.         for(int i=0;i<s.length;i++)  
14.             s[i]=new Semaphore(0);  
15.     };  
16. }  
17.   
18. class Philosopher implements Runnable{  
19.     private int pid; //当前哲学家的序号  
20.     private int lid; //坐在左手边的哲学家序号  
21.     private int rid; //坐在右手边的哲学家序号  
22.       
23.     Philosopher(int id){  
24.         this.pid=id;  
25.         this.lid=(id+4)%5;  
26.         this.rid=(id+1)%5;  
27.     }  
28.       
29.     private void test(int pid){  
30.         //如果当前哲学家左右手边的人都没有吃饭，则当前哲学家可以进餐  
31.         if(Signs.status[pid]==Signs.THINKING&&Signs.status[lid]!=Signs.EATING&&Signs.status[rid]!=Signs.EATING){  
32.             Signs.status[pid]=Signs.EATING; //此时当前哲学家线程可以进餐，但其他哲学家线程很可能无法进餐  
33.             Signs.s[pid].release(); //释放一个许可  
34.         }  
35.     }  
36.       
37.     public void run(){  
38.         try {  
39.             //尝试拿起叉子准备进餐  
40.             Signs.mutex.acquire();  
41.             test(pid);  
42.             Signs.mutex.release();  
43.                   
44.             //判断当前哲学家的进餐信号量，如果不能许可进餐，则当前线程阻塞  
45.             Signs.s[pid].acquire();  
46.             System.out.println("#"+pid+" 号哲学家正在进餐...");  
47.                   
48.             //放下叉子，并唤醒旁边两个被阻塞进餐的哲学家，让他们尝试进餐  
49.             Signs.mutex.acquire();  
50.             Signs.status[pid]=Signs.THINKING;  
51.             test(lid); //让左手边的哲学家尝试拿起叉子，如果可以，则释放这个哲学家的信号量许可  
52.             test(rid); //同上  
53.             Signs.mutex.release();  
54.         } catch (InterruptedException e) {  
55.             e.printStackTrace();  
56.         }  
57.     }  
58.       
59. }  
60.   
61.   
62. public class Test{  
63.   
64.     public static void main(String[] args) {  
65.         new Thread(new Philosopher(0)).start();  
66.         new Thread(new Philosopher(1)).start();  
67.         new Thread(new Philosopher(2)).start();  
68.         new Thread(new Philosopher(3)).start();  
69.         new Thread(new Philosopher(4)).start();  
70.     }  
71. }  

 

 

3、读者-写者问题 
 
读者一写者问题(Courtois et al., 1971)为数据库访问建立了一个模型。例如，设想一个飞机定票系统，其中有许多竞争的进程试图读写其中的数据。多个进程同时读是可以接受的，但如果一个进程正在写数据库、则所有的其他进程都不能访问数据库，即使读操作也不行。

Java代码   

1. import java.util.concurrent.Semaphore;  
2.   
3. class Sign{  
4.     static Semaphore db=new Semaphore(1); //信号量：控制对数据库的访问  
5.     static Semaphore mutex=new Semaphore(1); //信号量：控制对临界区的访问  
6.     static int rc=0; //记录正在读或者想要读的进程数  
7. }  
8. class Reader implements Runnable{  
9.       
10.     public void run(){  
11.         try {  
12.             //互斥对rc的操作  
13.             Sign.mutex.acquire();  
14.             Sign.rc++;  //又多了一个读线程  
15.             if(Sign.rc==1) Sign.db.acquire(); //如果是第一个读进程开始读取DB，则请求一个许可，使得写进程无法操作  
16.   
17. DB  
18.             Sign.mutex.release();  
19.                   
20.             //无临界区控制，多个读线程都可以操作DB  
21.             System.out.println("[R]   "+Thread.currentThread().getName()+": read data....");  
22.             Thread.sleep(100);  
23.               
24.             //互斥对rc的操作  
25.             Sign.mutex.acquire();  
26.             Sign.rc--;  
27.             if(Sign.rc==0) Sign.db.release(); //如果最后一个读进程读完了，则释放许可，让写进程有机会操作DB  
28.             Sign.mutex.release();  
29.   
30.         } catch (InterruptedException e) {  
31.             e.printStackTrace();  
32.         }  
33.     }  
34. }  
35. class Writer implements Runnable{  
36.       
37.     public void run(){  
38.         try {  
39.             //与读操作互斥访问DB  
40.             Sign.db.acquire();  
41.             System.out.println("[W]   "+Thread.currentThread().getName()+": write data....");  
42.             Thread.sleep(100);  
43.             Sign.db.release();  
44.         } catch (InterruptedException e) {  
45.             e.printStackTrace();  
46.         }  
47.       
48.     }  
49. }  
50. public class Test {  
51.   
52.     public static void main(String[] args){  
53.         new Thread(new Reader()).start();  
54.         new Thread(new Reader()).start();  
55.         new Thread(new Writer()).start();  
56.     }  
57. }  

 

 

4、理发师问题

      另一个经典的问题发生在理发店里。理发店里有一位理发师，一把理发椅和n把供等候理发的顾客坐的椅子。如果没有顾客，理发师便在理发椅上睡觉，当一个顾客到来时，他必须先叫醒理发师，如果理发师正在理发时又有顾客来到，则如果有空椅子可坐，他们就坐下来等;如果没有空椅子，他就离开。

Java代码   

1. import java.util.concurrent.Semaphore;  
2.   
3. class Sign{  
4.     final static int CHAIRS=5; //椅子数量  
5.     static int waiting=0; //等待理发的顾客数  
6.     static Semaphore consumers=new Semaphore(0); //信号量：等候服务的顾客数  
7.     static Semaphore barber=new Semaphore(0);  //信号量：等待顾客的理发师数  
8.     static Semaphore mutex=new Semaphore(1); //信号量：控制对临界区的访问  
9. }  
10.   
11. class Barber implements Runnable{  
12.       
13.     public void run(){  
14.         try {  
15.             while(true){  
16.                 Sign.consumers.acquire(); //如果顾客数是0，则理发师睡觉  
17.                 //互斥操作顾客等待waiting  
18.                 Sign.mutex.acquire();  
19.                 Sign.waiting--;   
20.                 Sign.barber.release(); //一个理发师现在开始理发  
21.                 Sign.mutex.release();  
22.                 System.out.println("理发师"+Thread.currentThread().getName()+"正在理发...");  
23.             }  
24.         } catch (InterruptedException e) {  
25.             e.printStackTrace();  
26.         }  
27.     }  
28. }  
29.   
30. class Customer implements Runnable{  
31.       
32.     public void run(){  
33.         try {  
34.             //互斥操作顾客等待waiting  
35.             Sign.mutex.acquire();  
36.             //如果还有椅子空余，则顾客坐在椅子上等待  
37.             if(Sign.waiting<Sign.CHAIRS){  
38.                 Sign.waiting++;  
39.                 Sign.consumers.release(); //顾客理  
40.                 Sign.mutex.release();  
41.                 Sign.barber.acquire(); //如果理发师数量为0，则顾客等待  
42.                 System.out.println("顾客"+Thread.currentThread().getName()+"正在被理发...");  
43.             }else{  
44.                 Sign.mutex.release(); //理发店满人，顾客走人  
45.             }  
46.         } catch (InterruptedException e) {  
47.             e.printStackTrace();  
48.         }  
49.       
50.     }  
51. }  
52.   
53.   
54. public class Test {  
55.   
56.     public static void main(String[] args){  
57.         new Thread(new Barber()).start();  
58.         new Thread(new Customer()).start();  
59.         new Thread(new Customer()).start();  
60.         new Thread(new Customer()).start();  
61.     }  
62. }