java线程 (一)生产者消费者模式-线程同步问题

转载请标明出处：

http://blog.csdn.net/xiaohai0504/article/details/7003975 

引言

　　生产者和消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一个存储空间，如下图所示，生产者向空间里存放数据，而消费者取用数据，如果不加以协调可能会出现以下情况：

生产者消费者图

　　存储空间已满，而生产者占用着它，消费者等着生产者让出空间从而去除产品，生产者等着消费者消费产品，从而向空间中添加产品。互相等待，从而发生死锁。

JAVA解决线程模型的三种方式

1、wait和notify

[java]  view plain copy

1. package com.ch.egg;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. public class ThreadEgg {  
7.     private List<Object> eggs = new ArrayList<Object>();  
8.       
9.     /** 
10.      * 若不拥有对象的锁标记(synchronized)，而试图用wait/notify协调共享对象资源， 
11.      * 应用程序将抛出IllegalMonitorStateException。 
12.      * 
13.      * @param i 
14.      * @return 
15.      */  
16.     public synchronized Object getEggs(int i) {  
17.         //若盘里鸡蛋为0，则wait()阻塞进入队列，等待生产者(放鸡蛋)线程唤醒  
18.         if(eggs.size() == 0) {  
19.             try {  
20.                 wait();  
21.             } catch (InterruptedException e) {  
22.                 e.printStackTrace();  
23.             }  
24.         }  
25.           
26.         Object egg = eggs.get(0);  
27.         eggs.clear();  
28.         notify();  
29.         System.out.println("拿到  鸡蛋"+i);  
30.           
31.         return egg;  
32.     }  
33.       
34.     public synchronized void pugEgg(Object egg,int i) {  
35.         //若盘里鸡蛋为1，则wait()阻塞进入队列，等待消费者(取鸡蛋)线程唤醒  
36.         if(eggs.size() > 0) {  
37.             try {  
38.                 wait();  
39.             } catch (InterruptedException e) {  
40.                 // TODO Auto-generated catch block  
41.                 e.printStackTrace();  
42.             }  
43.         }  
44.           
45.         eggs.add(egg);  
46.         notify();  
47.         System.out.println("放入  鸡蛋"+i);  
48.     }  
49.       
50.     static class AddThread extends Thread {  
51.         private ThreadEgg threadEgg;  
52.         private Object egg ;  
53.           
54.         public AddThread(ThreadEgg threadEgg) {  
55.             this.threadEgg = threadEgg;  
56.         }  
57.           
58.         public void run() {  
59.             for(int i = 0;i<5;i++){  
60.                 threadEgg.pugEgg(egg,i);  
61.             }  
62.         }  
63.     }  
64.       
65.     static class GetThread extends Thread{     
66.         private ThreadEgg threadEgg;  
67.         public GetThread(ThreadEgg threadEgg) {  
68.             this.threadEgg = threadEgg;  
69.         }  
70.              
71.         public void run(){     
72.             for(int i=0;i<5;i++){     
73.                 threadEgg.getEggs(i);     
74.             }     
75.         }     
76.     }   
77.       
78.     public static void main(String[] args) {  
79.         try {  
80.             ThreadEgg threadEgg = new ThreadEgg();  
81.             AddThread aTh = new AddThread(threadEgg);  
82.             GetThread gTh = new GetThread(threadEgg);  
83.             aTh.start();  
84.             gTh.start();  
85.             aTh.join();  
86.             gTh.join();  
87.         } catch (InterruptedException e) {  
88.             // TODO Auto-generated catch block  
89.             e.printStackTrace();  
90.         }  
91.         System.out.println("over......");  
92.           
93.     }  
94. }  

2、await()和signal()，即线程锁的方式

[java]  view plain copy

1. package com.ch.egg;  
2.   
3. import java.util.LinkedList;  
4. import java.util.concurrent.locks.Condition;  
5. import java.util.concurrent.locks.Lock;  
6. import java.util.concurrent.locks.ReentrantLock;  
7.   
8. /** 
9.  * ReentrantLock 是一个可重入的互斥锁 Lock， 
10.  * 它具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大 
11.  *  
12.  * Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象， 
13.  * 以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。 
14.  * 其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。 
15.  *  
16.  * @author ch 
17.  * 
18.  */  
19. public class ThreadEggLock {  
20.   
21.     private LinkedList<Object> eggs = new LinkedList<Object>();  
22.     private int MAX = 1;  
23.     private final Lock lock = new ReentrantLock();  
24.     private final Condition full = lock.newCondition();  
25.     private final Condition empty = lock.newCondition();  
26.   
27.     private int count = 0;  
28.       
29.     public void start() {  
30.         new Producer().start();  
31.         new Consumer().start();  
32.     }  
33.     public static void main(String[] args) throws Exception {  
34.         ThreadEggLock s2 = new ThreadEggLock();  
35.         s2.start();  
36.     }  
37.   
38.     class Producer extends Thread {  
39.         public void run() {  
40.             while (count < 5) {  
41.                 lock.lock();  
42.                 try {  
43.                     while (eggs.size() == MAX) { //盘子里满了  
44.                         System.out.println("------警告：盘子里满了!");  
45.                         full.await();  
46.                     }  
47.                     Object egg = new Object();  
48.                     if (eggs.add(egg)) {  
49.                         System.out.println("放入  鸡蛋" + count);  
50.                         empty.signal();  
51.                     }  
52.                 } catch (InterruptedException ie) {  
53.                     System.out.println("producer is interrupted!");  
54.                 } finally {  
55.                     lock.unlock();  
56.                 }  
57.             }  
58.         }  
59.     }  
60.   
61.     class Consumer extends Thread {  
62.         public void run() {  
63.             while (count <= 5) {  
64.                 lock.lock();  
65.                 try {  
66.                     while (eggs.size() == 0) { //盘子是空的  
67.                         System.out.println("------警告：现在盘子是空的");  
68.                         empty.await();  
69.                     }  
70.                       
71.                     eggs.removeLast();  
72.                     System.out.println("拿走  鸡蛋" + count);  
73.                     count++;  
74.                     full.signal();  
75.                 } catch (InterruptedException ie) {  
76.                     System.out.println("consumer is interrupted!");  
77.                 } finally {  
78.                     lock.unlock();  
79.                 }  
80.             }  
81.         }  
82.     }  
83.   
84. }  

3、阻塞队列的方式

[java]  view plain copy

1. package com.ch.egg;  
2.   
3. import java.util.concurrent.LinkedBlockingQueue;  
4.   
5. public class ThreadEggBlock {  
6.     // 建立一个阻塞队列  
7.     /** 
8.      * 一个基于已链接节点的、范围任意的 blocking queue。 
9.      * 此队列按 FIFO（先进先出）排序元素。 
10.      * 队列的头部 是在队列中时间最长的元素;队列的尾部 是在队列中时间最短的元素。 
11.      *  
12.      * 新元素插入到队列的尾部，并且队列获取操作会获得位于队列头部的元素。 
13.      * 链接队列的吞吐量通常要高于基于数组的队列，但是在大多数并发应用程序中，其可预知的性能要低。  
14.      */  
15.     private LinkedBlockingQueue<Object> queue_eggs =   
16.         new LinkedBlockingQueue<Object>(1);  
17.     private int count = 1;  
18.   
19.     public void start() throws InterruptedException {  
20.         Producer producer = new Producer();  
21.         Consumer consumer = new Consumer();  
22.         producer.start();  
23.         consumer.start();  
24.     }  
25.     public static void main(String[] args) throws Exception {  
26.         ThreadEggBlock s3 = new ThreadEggBlock();  
27.         s3.start();  
28.     }  
29.   
30.     class Producer extends Thread {  
31.         public void run() {  
32.             while (count < 15) {  
33.                 try {  
34.                     Egg egg = new Egg(String.valueOf(count));  
35.                     queue_eggs.put(egg);  
36.                     System.out.println("放入  鸡蛋" + egg.getName());  
37.                     count++;  
38.                 } catch (InterruptedException e) {  
39.                     System.out.println("producer is interrupted!");  
40.                 }  
41.             }  
42.         }  
43.     }  
44.   
45.     class Consumer extends Thread {  
46.         public void run() {  
47.             while (count <= 15) {  
48.                 try {  
49.                     // 取出一个对象  
50.                     Egg egg = (Egg) queue_eggs.take();  
51.                     System.out.println("取出  鸡蛋" + egg.getName());  
52.                 } catch (InterruptedException e) {  
53.                     System.out.println("producer is interrupted!");  
54.                 }  
55.             }  
56.         }  
57.     }  
58.   
59.     class Egg {  
60.         private String name;  
61.           
62.         public Egg(String name) {  
63.             this.name = name;  
64.         }  
65.           
66.         public String getName() {  
67.             return name;  
68.         }  
69.   
70.         public void setName(String name) {  
71.             this.name = name;  
72.         }  
73.     }  
74. }  

总结：

1、处理多线程同步与互斥问题非常重要，著名的生产者-消费者例子就是一个经典的例子，是任何语言多线程必学的例子。

2、三种方式实现同步的原理一致，都是对独占空间加锁，阻塞和唤醒线程；第一种方式比较传统，第二种方式最灵活，第三种方式最简单，只需存储和取用，线程同步的操作交由LinkedBlockingQueue全权处理。 

线程同步小结

1、线程同步的目的是为了保护多个线程访问一个资源时对资源的破坏。

2、线程同步方法是通过锁来实现， 每个对象都有且仅有一个锁，这个锁与一个特定的对象关联；线程一旦获取了对象锁，其他访问该对象的线程就无法再访问该对象的其他同步方法。

3、对于 静态同步方法， 锁是针对这个类的，锁对象是该类的Class对象。静态和非静态方法的锁互不干预。一个线程获得锁，当在一个同步方法中访问另外对象上的同步方法时，会获取这两个对象锁。

4、对于同步，要时刻明白是在哪个对象上同步。

5、在使用synchronized关键字时候， 应该尽可能避免在synchronized方法或synchronized块中使用sleep或者yield方法，因为synchronized程序块占有着对象锁，你休息那么其他的线程只能一边等着你醒来执行完了才能执行。不但严重影响效率，也不合逻辑。同样，在同步程序块内调用yeild方法让出CPU资源也没有意义，因为你占用着锁，其他互斥线程还是无法访问同步程序块。当然与同步程序块无关的线程可以获得更多的执行时间。

6、编写线程安全的类，需要时刻注意对多个线程竞争访问资源的逻辑和安全做出正确的判断，对“原子”操作做出分析，并保证原子操作期间别的线程无法访问竞争资源。

7、当多个线程等待一个对象锁时，没有获取到锁的线程将发生阻塞。

8、死锁是线程间相互等待锁锁造成的，一旦程序发生死锁，程序将死掉。