由生产者/消费者问题看JAVA多线程

转: http://blog.csdn.net/coutcin/article/details/1213834

生产者消费者问题是研究多线程程序时绕不开的问题，它的描述是有一块生产者和消费者共享的有界缓冲区，生产者往缓冲区放入产品，消费者从缓冲区取走产品，这个过程可以无休止的执行，不能因缓冲区满生产者放不进产品而终止，也不能因缓冲区空消费者无产品可取而终止。

       解决生产者消费者问题的方法有两种，一种是采用某种机制保持生产者和消费者之间的同步，一种是在生产者和消费者之间建立一个管道。前一种有较高的效率并且可控制性较好，比较常用，后一种由于管道缓冲区不易控制及被传输数据对象不易封装等原因，比较少用。

       同步问题的核心在于，CPU是按时间片轮询的方式执行程序，我们无法知道某一个线程是否被执行、是否被抢占、是否结束等，因此生产者完全可能当缓冲区已满的时候还在放入产品，消费者也完全可能当缓冲区为空时还在取出产品。

       现在同步问题的解决方法一般是采用信号或者加锁机制，即生产者线程当缓冲区已满时放弃自己的执行权，进入等待状态，并通知消费者线程执行。消费者线程当缓冲区已空时放弃自己的执行权，进入等待状态，并通知生产者线程执行。这样一来就保持了线程的同步，并避免了线程间互相等待而进入死锁状态。

       JAVA语言提供了独立于平台的线程机制，保持了”write once, run anywhere”的特色。同时也提供了对同步机制的良好支持。

       在JAVA中，一共有四种方法支持同步，其中三个是同步方法，一个是管道方法。

1.        方法 wait()/notify()

2.        方法await()/signal()

3.        阻塞队列方法BlockingQueue

4.        管道方法PipedInputStream/PipedOutputStream

下面我们看各个方法的实现：

1.        方法wait()/notify()

wait()和notify()是根类Object的两个方法，也就意味着所有的JAVA类都会具有这个两个方法，为什么会被这样设计呢？我们可以认为所有的对象默认都具有一个锁，虽然我们看不到，也没有办法直接操作，但它是存在的。

wait()方法表示：当缓冲区已满或空时，生产者或消费者线程停止自己的执行，放弃锁，使自己处于等待状态，让另一个线程开始执行；

notify()方法表示：当生产者或消费者对缓冲区放入或取出一个产品时，向另一个线程发出可执行通知，同时放弃锁，使自己处于等待状态。

下面是一个例子代码：

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. import java.util.Random;  
4. //使用wait和notify来实现生产者和消费者的关系  
5. public class Sycn1 {  
6.     private List<Integer> list = new LinkedList<Integer>();  
7.     private int MaxNum = 10;  
8.     public static void main(String[] args) {  
9.         new Sycn1().start();  
10.     }  
11.     private void start(){  
12.         new Product().start();  
13.         new Consumer().start();  
14.     }  
15.     private static int getInt(){  
16.         try {  
17.             Thread.sleep(500);  
18.         } catch (InterruptedException e) {e.printStackTrace();}  
19.         return new Random().nextInt(9)+1;  
20.     }  
21.     class Product extends Thread{  
22.         @Override  
23.         public void run() {  
24.             while(true){  
25.                 synchronized(list){  
26.                     while(list.size() == MaxNum){//使用while比使用if要安全点,因为可能消费异常但notify  
27.                         try {  
28.                             System.out.println("生产已满.等待消费.....");  
29.                             list.wait();  
30.                         } catch (InterruptedException e) {e.printStackTrace();}  
31.                     }  
32.                     int i = getInt();  
33.                     if(list.add(i)){  
34.                         System.out.println("生产元素为:"+i+"#当前元素列表:"+list);  
35.                         list.notify();  
36.                     }  
37.                 }  
38.             }  
39.         }  
40.     }  
41.     class Consumer extends Thread{  
42.         @Override  
43.         public void run() {  
44.             while(true){  
45.                 synchronized(list){  
46.                     while(list.size()==0){  
47.                         try {  
48.                             System.out.println("消费已空.等待生产.....");  
49.                             list.wait();  
50.                         } catch (InterruptedException e) {e.printStackTrace();}  
51.                     }  
52.                     int i = list.remove(list.size()-1);  
53.                     System.out.println("消费元素为:"+i+"#当前元素列表:"+list);  
54.                     list.notify();  
55.                 }  
56.             }  
57.         }  
58.     }  
59.     /** 
60.      * 运行结果: 
61.      *  生产元素为:3#当前元素列表:[3] 
62.         生产元素为:9#当前元素列表:[3, 9] 
63.         生产元素为:9#当前元素列表:[3, 9, 9] 
64.         消费元素为:9#当前元素列表:[3, 9] 
65.         消费元素为:9#当前元素列表:[3] 
66.         消费元素为:3#当前元素列表:[] 
67.         消费已空.等待生产..... 
68.         生产元素为:3#当前元素列表:[3] 
69.         消费元素为:3#当前元素列表:[] 
70.         消费已空.等待生产..... 
71.         生产元素为:2#当前元素列表:[2] 
72.      */  
73. }  

2.        方法await()/signal()

在JDK5.0以后，JAVA提供了新的更加健壮的线程处理机制，包括了同步、锁定、线程池等等，它们可以实现更小粒度上的控制。await()和signal()就是其中用来做同步的两种方法，它们的功能基本上和wait()/notify()相同，完全可以取代它们，但是它们和新引入的锁定机制Lock直接挂钩，具有更大的灵活性。

下面是一个例子代码：

[java]  view plain copy

1. import java.util.LinkedList;  
2. import java.util.Random;  
3. import java.util.concurrent.locks.Condition;  
4. import java.util.concurrent.locks.Lock;  
5. import java.util.concurrent.locks.ReentrantLock;  
6. public class Sycn2 {  
7.     private Lock lock = new ReentrantLock();  
8.     private Condition full = lock.newCondition();  
9.     private Condition empty = lock.newCondition();  
10.     private int MaxNum = 5;  
11.     private LinkedList<Integer> list = new LinkedList<Integer>();  
12.     public static void main(String[] args) {  
13.         new Sycn2().start();  
14.     }  
15.     public void start(){  
16.         new Product().start();  
17.         new Consumer().start();  
18.     }  
19.     private static void mysleep(){  
20.         try {  
21.             Thread.sleep(500);  
22.         } catch (InterruptedException e) {  
23.             e.printStackTrace();  
24.         }  
25.     }  
26.     class Product extends Thread{  
27.         @Override  
28.         public void run(){  
29.             while(true){  
30.                 try{  
31.                     lock.lock();  
32.                     while(list.size() == MaxNum){  
33.                         System.out.println("product---await----");  
34.                         full.await();  
35.                     }  
36.                     int rand = new Random().nextInt(100);  
37.                     list.add(rand);  
38.                     System.out.println("Product@"+list+"#"+rand);  
39.                     empty.signal();  
40.                     mysleep();  
41.                 }catch(Exception e){  
42.                     e.printStackTrace();  
43.                 }finally{  
44.                     lock.unlock();  
45.                 }  
46.             }  
47.         }  
48.     }  
49.     class Consumer extends Thread{  
50.         @Override  
51.         public void run(){  
52.             while(true){  
53.                 try{  
54.                     lock.lock();  
55.                     while(list.size() == 0){  
56.                         System.out.println("consumer---await----");  
57.                         empty.await();  
58.                     }  
59.                     System.out.println("Consumer@"+list+"#"+list.removeLast());  
60.                     full.signal();  
61.                     mysleep();  
62.                 }catch(Exception e){  
63.                     e.printStackTrace();  
64.                 }finally{  
65.                     lock.unlock();  
66.                 }  
67.             }  
68.         }  
69.     }  
70.     /** 
71.      * 运行结果： 
72.         Product@[60]#60 
73.         Product@[60, 58]#58 
74.         Product@[60, 58, 81]#81 
75.         Product@[60, 58, 81, 41]#41 
76.         Product@[60, 58, 81, 41, 0]#0 
77.         product---await---- 
78.         Consumer@[60, 58, 81, 41, 0]#0 
79.         Consumer@[60, 58, 81, 41]#41 
80.         Consumer@[60, 58, 81]#81 
81.         Consumer@[60, 58]#58 
82.         Consumer@[60]#60 
83.         consumer---await---- 
84.         Product@[27]#27 
85.      */  
86. }  

3.        阻塞队列方法BlockingQueue

   注：BlockingQueue 可以安全地与多个生产者和多个使用者一起使用。

BlockingQueue也是JDK5.0的一部分，它是一个已经在内部实现了同步的队列，实现方式采用的是我们的第2种await()/signal()方法。它可以在生成对象时指定容量大小。

它用于阻塞操作的是put()和take()方法。

put()方法类似于我们上面的生产者线程，容量最大时，自动阻塞。

take()方法类似于我们上面的消费者线程，容量为0时，自动阻塞。

下面是一个例子代码：

[java]  view plain copy

1. import java.util.concurrent.*;  
2.   
3. public class Sycn3{  
4.     private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);  
5.     private int MAX = 10;  
6.       
7.     public Sycn3(){  
8.     }  
9.       
10.     public void start(){  
11.             new Producer().start();  
12.             new Consumer().start();  
13.     }  
14.       
15.     public static void main(String[] args) throws Exception{  
16.         Sycn3 s3 = new Sycn3();  
17.         s3.start();  
18.     }  
19.       
20.     class Producer extends Thread{          
21.         public void run(){  
22.             while(true){  
23.                 //synchronized(this){  
24.                 try{  
25.                     if(queue.size() == MAX)  
26.                         System.out.println("warning: it's full!");  
27.                     Object o = new Object();  
28.                     queue.put(o);  
29.                     System.out.println("Producer: " + o);  
30.                     }catch(InterruptedException e){  
31.                         System.out.println("producer is interrupted!");  
32.                     }  
33.                 //}  
34.             }  
35.         }  
36.     }  
37.     class Consumer extends Thread{  
38.         public void run(){  
39.             while(true){  
40.                 //synchronized(this){  
41.                 try{  
42.                     if(queue.size() == 0)  
43.                         System.out.println("warning: it's empty!");  
44.                     Object o = queue.take();  
45.                     System.out.println("Consumer: " + o);  
46.                     }catch(InterruptedException e){  
47.                         System.out.println("producer is interrupted!");  
48.                     }  
49.                 //}  
50.             }  
51.         }  
52.     }  
53. }  

你发现这个例子中的问题了吗？

如果没有，我建议你运行一下这段代码，仔细观察它的输出，是不是有下面这个样子的？为什么会这样呢？

…

warning: it's full!

Producer: java.lang.object@4526e2a

…

你可能会说这是因为put()和System.out.println()之间没有同步造成的，我也这样认为，我也这样认为，但是你把run()中的synchronized前面的注释去掉，重新编译运行，有改观吗？没有。为什么？

这是因为，当缓冲区已满，生产者在put()操作时，put()内部调用了await()方法，放弃了线程的执行，然后消费者线程执行，调用take()方法，take()内部调用了signal()方法，通知生产者线程可以执行，致使在消费者的println()还没运行的情况下生产者的println()先被执行，所以有了上面的输出。run()中的synchronized其实并没有起什么作用。

对于BlockingQueue大家可以放心使用，这可不是它的问题，只是在它和别的对象之间的同步有问题。

对于这种多重嵌套同步的问题，以后再谈吧，欢迎大家讨论啊！

4.        管道方法PipedInputStream/PipedOutputStream

这个类位于java.io包中，是解决同步问题的最简单的办法，一个线程将数据写入管道，另一个线程从管道读取数据，这样便构成了一种生产者/消费者的缓冲区编程模式。

管道流可以用于线程间通信，当程序中存在多线程，并且某个线程的运行需要得到另一个线程的信息时， 可以用管道流作为媒介来传输信息。管道流属于线程间通信的一种

下面是一个例子代码，在这个代码我没有使用Object对象，而是简单的读写字节值，这是因为PipedInputStream/PipedOutputStream不允许传输对象，这是JAVA本身的一个bug,具体的大家可以看sun的解释： http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4131126

[java]  view plain copy

1. import java.io.IOException;  
2. import java.io.PipedInputStream;  
3. import java.io.PipedOutputStream;  
4. import java.util.Random;  
5. public class Sycn4 {  
6.     private PipedOutputStream pos;  
7.     private PipedInputStream pis;  
8.     public Sycn4(){  
9.         pos = new PipedOutputStream();  
10.         try {  
11.             pis = new PipedInputStream(pos);  
12.         } catch (IOException e) {  
13.             e.printStackTrace();  
14.         }  
15.     }  
16.     public static void main(String[] args) {  
17.         new Sycn4().start();  
18.     }  
19.     public void start(){  
20.         new Product().start();  
21.         new Consumer().start();  
22.     }  
23.     private static void mysleep(){  
24.         try {  
25.             Thread.sleep(500);  
26.         } catch (InterruptedException e) {  
27.             e.printStackTrace();  
28.         }  
29.     }  
30.     class Product extends Thread{  
31.         @Override  
32.         public void run(){  
33.             try {  
34.                 while(true){  
35.                     int rand = new Random().nextInt(100);  
36.                     pos.write(rand);  
37.                     pos.flush();  
38.                     System.out.println("product@"+rand);  
39.                     mysleep();  
40.                 }  
41.             } catch (IOException e) {  
42.                 e.printStackTrace();  
43.             }finally{  
44.                 try {  
45.                     pos.close();  
46.                     pis.close();  
47.                 } catch (IOException e) {  
48.                     e.printStackTrace();  
49.                 }  
50.             }  
51.         }  
52.     }  
53.     class Consumer extends Thread{  
54.         @Override  
55.         public void run(){  
56.             try {  
57.                 while(true){  
58.                     System.out.println("Consumer@"+pis.read());  
59.                     mysleep();  
60.                 }  
61.             } catch (IOException e) {  
62.                 e.printStackTrace();  
63.             }finally{  
64.                 try {  
65.                     pos.close();  
66.                     pis.close();  
67.                 } catch (IOException e) {  
68.                     e.printStackTrace();  
69.                 }  
70.             }  
71.         }  
72.     }  
73.     /** 
74.      * 运行结果： 
75.      *  product@37 
76.         Consumer@37 
77.         product@98 
78.         Consumer@98 
79.         product@20 
80.         Consumer@20 
81.         product@70 
82.         Consumer@70 
83.      */  
84. }  

5.使用信号量的方式实现，转:http://blog.csdn.net/a442180673/article/details/7309954

[java]  view plain copy

1. import java.util.Random;  
2. import java.util.concurrent.Semaphore;  
3. /** 
4.  * 生产者与消费者的问题 
5.  *  
6.  */  
7. class Signs {  
8.     static Semaphore empty = new Semaphore(10); // 信号量：记录仓库空的位置，代表可以生产的最大个数  
9.     static Semaphore full = new Semaphore(0); // 信号量：记录仓库满的位置  
10.     static Semaphore mutex = new Semaphore(1); // 临界区互斥访问信号量， 相当于互斥锁。  
11. }  
12.   
13. // 生产一个产品  
14. class Producer implements Runnable {  
15.     Random r = new Random(1000);  
16.   
17.     public void run() {  
18.         try {  
19.             while (true) {  
20.                 Signs.empty.acquire(); // 递减仓库空信号量  
21.                 Signs.mutex.acquire(); // 进入临界区  
22.                 SemaphoreTest.COUNT++;  
23.                 System.out.println("生产一个产品放入仓库,剩余：" + SemaphoreTest.COUNT);  
24.   
25.                 Signs.mutex.release(); // 离开临界区  
26.                 Signs.full.release(); // 递增仓库满信号量  
27.                 Thread.currentThread().sleep(100);  
28.             }  
29.         } catch (InterruptedException e) {  
30.             e.printStackTrace();  
31.         }  
32.     }  
33. }  
34.   
35. // 消费一个产品  
36. class Consumer implements Runnable {  
37.   
38.     public void run() {  
39.         try {  
40.             while (true) {  
41.                 Signs.full.acquire(); // 递减仓库满信号量  
42.                 Signs.mutex.acquire();  
43.                 SemaphoreTest.COUNT--;  
44.                 System.out.println("C1拿出一个产品消费，剩余：" + SemaphoreTest.COUNT);  
45.   
46.                 Signs.mutex.release();  
47.                 Signs.empty.release(); // 递增仓库空信号量  
48.                 Thread.currentThread().sleep((1000));  
49.             }  
50.         } catch (InterruptedException e) {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54. }  
55.   
56. class Consumer2 implements Runnable {  
57.   
58.     public void run() {  
59.         try {  
60.             while (true) {  
61.                 Signs.full.acquire(); // 递减仓库满信号量  
62.                 Signs.mutex.acquire();  
63.                 SemaphoreTest.COUNT--;  
64.                 System.out.println("C2拿出一个产品消费，剩余：" + SemaphoreTest.COUNT);  
65.   
66.                 Signs.mutex.release();  
67.                 Signs.empty.release(); // 递增仓库空信号量  
68.                 Thread.currentThread().sleep((500));  
69.             }  
70.         } catch (InterruptedException e) {  
71.             e.printStackTrace();  
72.         }  
73.     }  
74. }  
75.   
76. public class SemaphoreTest {  
77.     public static int COUNT = 0;  
78.     // 产品数目  
79.     public static void main(String[] args) {  
80.         new Thread(new Producer()).start();  
81.         new Thread(new Consumer()).start();  
82.         new Thread(new Consumer2()).start();  
83.     }  
84.     /** 
85.      * 运行结果： 
86.      *  生产一个产品放入仓库,剩余：1 
87.         C2拿出一个产品消费，剩余：0 
88.         生产一个产品放入仓库,剩余：1 
89.         C1拿出一个产品消费，剩余：0 
90.         生产一个产品放入仓库,剩余：1 
91.         生产一个产品放入仓库,剩余：2 
92.         生产一个产品放入仓库,剩余：3 
93.         C2拿出一个产品消费，剩余：2 
94.         生产一个产品放入仓库,剩余：3 
95.         生产一个产品放入仓库,剩余：4 
96.         生产一个产品放入仓库,剩余：5 
97.         生产一个产品放入仓库,剩余：6 
98.         生产一个产品放入仓库,剩余：7 
99.         C2拿出一个产品消费，剩余：6 
100.         生产一个产品放入仓库,剩余：7 
101.         C1拿出一个产品消费，剩余：6 
102.         生产一个产品放入仓库,剩余：7 
103.         生产一个产品放入仓库,剩余：8 
104.         生产一个产品放入仓库,剩余：9 
105.         生产一个产品放入仓库,剩余：10 
106.         C2拿出一个产品消费，剩余：9 
107.      */  
108. }