（13）多线程与并发库之java5阻塞队列(BlockingQueue)的应用----子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程循环100次，如此循环50次

首先复习一下：

1，内部类的实例方法不能在静态中创建。

2，成员变量 在什么情况情况下才有值啊？在创建了类的实例对象的时候，才分配空间。这时，就需要一个构造方法来进行赋值。

3，static{ 

}这种语法，不需要创建实例对象 就可以运行，而bq1，bq2 是对象创建后的成员变量，对象里面的变量，所以不可应用静态代码块。

    要用 这种匿名构造方法{ }  它的运行时机 在任何构造方法之前，只要调用 构造方法，匿名构造方法都会执行，也就是说   创建了几个对象，匿名构造方法就会执行几次。

      而 静态代码块 是在 类加载的时候 执行。且 只调用一次。 

分析：

            本例介绍一个特殊的队列:BlockingQueue,如果BlockQueue是空的,从BlockingQueue取东西的操作将会被阻断进入等待状态,直到BlockingQueue进了东西才会被唤醒.同样,如果BlockingQueue是满的,任何试图往里存东西的操作也会被阻断进入等待状态,直到BlockingQueue里有空间才会被唤醒继续操作.

首先开启两个线程，

第一轮：queue1 刚开始为空的，所以它就想放入（put）数据。

而queue2刚开始为满的，这时他也想放入（put）数据，所以queue2就堵塞在那里了。

第二轮：1线程的queue2这时取出（take）数据，哈哈，这时 2 线程上的queue2就可以走了。

如图：

说明：阻塞对列和Semaphore有些类似，但也不同，阻塞队列是一方存数据，另一方取数据。而Semaphire通常是由同一方设置和释放信号量。

java.util.concurrent 
接口 BlockingQueue<E>

类型参数：

E - 在此 collection 中保持的元素类型

所有超级接口：

Collection<E>,  Iterable<E>,  Queue<E>

所有已知子接口：

BlockingDeque<E>

所有已知实现类：

ArrayBlockingQueue,  DelayQueue,  LinkedBlockingDeque, LinkedBlockingQueue, PriorityBlockingQueue, SynchronousQueue

---

public interface BlockingQueue<E>
   
   
    
    extends 
    
    Queue<E>
   
   

支持两个附加操作的 Queue，这两个操作是：获取元素时等待队列变为非空，以及存储元素时等待空间变得可用。

BlockingQueue 方法以四种形式出现，对于不能立即满足但可能在将来某一时刻可以满足的操作，这四种形式的处理方式不同：第一种是抛出一个异常，第二种是返回一个特殊值（null 或false，具体取决于操作），第三种是在操作可以成功前，无限期地阻塞当前线程，第四种是在放弃前只在给定的最大时间限制内阻塞。下表中总结了这些方法：

	抛出异常	特殊值	阻塞	超时
插入	add(e)	offer(e)	put(e)	offer(e, time, unit)
移除	remove()	poll()	take()	poll(time, unit)
检查	element()	peek()	不可用	不可用

BlockingQueue 不接受null 元素。试图add、put 或offer 一个null 元素时，某些实现会抛出NullPointerException。null 被用作指示poll 操作失败的警戒值。

【1】BlockingQueue 可以是限定容量的。它在任意给定时间都可以有一个remainingCapacity，超出此容量，便无法无阻塞地put 附加元素。没有任何内部容量约束的BlockingQueue 总是报告Integer.MAX_VALUE 的剩余容量。

【2】BlockingQueue 实现主要用于生产者-使用者队列，但它另外还支持Collection 接口。因此，举例来说，使用remove(x) 从队列中移除任意一个元素是有可能的。然而，这种操作通常不 会有效执行，只能有计划地偶尔使用，比如在取消排队信息时。

【3】BlockingQueue 实现是线程安全的。所有排队方法都可以使用内部锁或其他形式的并发控制来自动达到它们的目的。然而，大量的 Collection 操作（addAll、containsAll、retainAll 和removeAll）没有 必要自动执行，除非在实现中特别说明。因此，举例来说，在只添加了c 中的一些元素后，addAll(c) 有可能失败（抛出一个异常）。

【4】BlockingQueue 实质上不 支持使用任何一种“close”或“shutdown”操作来指示不再添加任何项。这种功能的需求和使用有依赖于实现的倾向。例如，一种常用的策略是：对于生产者，插入特殊的end-of-stream 或poison 对象，并根据使用者获取这些对象的时间来对它们进行解释。

以下是基于典型的生产者-使用者场景的一个用例。注意，BlockingQueue 可以安全地与多个生产者和多个使用者一起使用。 

[java]  view plain copy print ?

1. class Producer implements Runnable {  
2.    private final BlockingQueue queue;  
3.    Producer(BlockingQueue q) { queue = q; }  
4.    public void run() {  
5.      try {  
6.        while(true) { queue.put(produce()); }  
7.      } catch (InterruptedException ex) { ... handle ...}  
8.    }  
9.    Object produce() { ... }  
10.  }  
11.   
12.  class Consumer implements Runnable {  
13.    private final BlockingQueue queue;  
14.    Consumer(BlockingQueue q) { queue = q; }  
15.    public void run() {  
16.      try {  
17.        while(true) { consume(queue.take()); }  
18.      } catch (InterruptedException ex) { ... handle ...}  
19.    }  
20.    void consume(Object x) { ... }  
21.  }  
22.   
23.  class Setup {  
24.    void main() {  
25.      BlockingQueue q = new SomeQueueImplementation();  
26.      Producer p = new Producer(q);  
27.      Consumer c1 = new Consumer(q);  
28.      Consumer c2 = new Consumer(q);  
29.      new Thread(p).start();  
30.      new Thread(c1).start();  
31.      new Thread(c2).start();  
32.    }  
33.  }  

内存一致性效果：当存在其他并发 collection 时，将对象放入  BlockingQueue  之前的线程中的操作  happen-before  随后通过另一线程从  BlockingQueue  中访问或移除该元素的操作。 

示例代码：

[java]  view plain copy print ?

1. package com.itm.thread;  
2.   
3. import java.util.concurrent.ArrayBlockingQueue;  
4. import java.util.concurrent.BlockingQueue;  
5. import java.util.concurrent.locks.Condition;  
6. import java.util.concurrent.locks.Lock;  
7. import java.util.concurrent.locks.ReentrantLock;  
8.   
9. /********* 
10.  *  
11.  * 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，接着再回到主线程循环100次，如此循环50次，请写出程序 
12.  *  
13.  *  
14.  * @author 
15.  *  
16.  */  
17. public class BlockingQueueCommunication3 {  
18.   
19.     public static void main(String[] args) {  
20.   
21.         final Business business = new Business();  
22.   
23.         new Thread(new Runnable() {  
24.             @Override  
25.             public void run() {  
26.                 for (int i = 1; i <= 50; i++) {  
27.                     //                    
28.                     business.sub(i);  
29.                 }  
30.             }  
31.         }).start();  
32.   
33.         // 主线程。  
34.         for (int i = 1; i <= 50; i++) {  
35.             //            
36.             business.main(i);  
37.         }  
38.   
39.     }  
40.   
41.     static class Business {  
42.     //  产生 两个队列。  
43.         BlockingQueue<Integer> bq1 = new ArrayBlockingQueue<Integer>(1);  
44.         BlockingQueue<Integer> bq2 = new ArrayBlockingQueue<Integer>(1);  
45.         {  
46.             try {  
47.                 bq2.put(1);  
48.             } catch (InterruptedException e) {  
49.                 e.printStackTrace();  
50.             }  
51.         }  
52.           
53.   
54.         public synchronized void sub(int i) {  
55.               
56.             try {  
57.                 bq1.put(1);  
58.             } catch (InterruptedException e) {  
59.                 // TODO Auto-generated catch block  
60.                 e.printStackTrace();  
61.             }  
62.             for (int j = 1; j <= 10; j++) {  
63.                 System.out.println("sub thread sequece of " + j + ", loop of "  
64.                         + i);  
65.             }  
66.             try {  
67.                 bq2.take();// 这样就可以 让第二个线程 把数据放进去了  bq2就可以执行了。  
68.             } catch (InterruptedException e) {  
69.                 // TODO Auto-generated catch block  
70.                 e.printStackTrace();  
71.             }  
72.               
73.   
74.         }  
75.   
76.         public synchronized void main(int i) {  
77.             try {  
78.                 bq2.put(1);  
79.             } catch (InterruptedException e) {  
80.                 // TODO Auto-generated catch block  
81.                 e.printStackTrace();  
82.             }// 不能让它走，就要往bq2中 提前放入数据。在还没有运行之前 就给他放入一个数据，就应该在构造方法中 放入。  
83.             for (int j = 1; j <= 100; j++) {  
84.                 System.out.println("main thread sequece of " + j + ", loop of "  
85.                         + i);  
86.             }  
87.             try {  
88.                 bq1.take();// 通知 bq1去取数据  
89.             } catch (InterruptedException e) {  
90.                 // TODO Auto-generated catch block  
91.                 e.printStackTrace();  
92.             }  
93.   
94.         }  
95.     }  
96.   
97. }  

运行结果：

死锁。

原因：没有把synchronized 关键字 去掉，所以造成了死锁。

使用BlockingQueue的关键技术点如下:

    1.BlockingQueue定义的常用方法如下:

        1)add(anObject):把anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则招聘异常

        2)offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.

        3)put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

        4)poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间,取不到时返回null

        5)take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到Blocking有新的对象被加入为止

    2.BlockingQueue有四个具体的实现类,根据不同需求,选择不同的实现类

        1)ArrayBlockingQueue:规定大小的BlockingQueue,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的.

        2)LinkedBlockingQueue:大小不定的BlockingQueue,若其构造函数带一个规定大小的参数,生成的BlockingQueue有大小限制,若不带大小参数,所生成的BlockingQueue的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的

        3)PriorityBlockingQueue:类似于LinkedBlockQueue,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序.

        4)SynchronousQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成的.

    3.LinkedBlockingQueue和ArrayBlockingQueue比较起来,它们背后所用的数据结构不一样,导致LinkedBlockingQueue的数据吞吐量要大于ArrayBlockingQueue,但在线程数量很大时其性能的可预见性低于ArrayBlockingQueue.