18.Java5阻塞队列的应用

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

第一个元素（头部）
	抛出异常	特殊值	阻塞	超时期
插入	addFirst(e)	offerFirst(e)	putFirst(e)	offerFirst(e, time, unit)
移除	removeFirst()	pollFirst()	takeFirst()	pollFirst(time, unit)
检查	getFirst()	peekFirst()	不适用	不适用
最后一个元素（尾部）
	抛出异常	特殊值	阻塞	超时期
插入	addLast(e)	offerLast(e)	putLast(e)	offerLast(e, time, unit)
移除	removeLast()	pollLast()	takeLast()	pollLast(time, unit)
检查	getLast()	peekLast()	不适用	不适用

像所有 BlockingQueue 一样，BlockingDeque 是线程安全的，但不允许 null 元素，并且可能有（也可能没有）容量限制。 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

/**
 * 18.Java5阻塞队列的应用
 * 可阻塞的队列
 *     队列包含固定长度的队列和不固定长度的队列。
 *     什么是可阻塞队列，阻塞队列的作用与实际应用。阻塞队列的实现原理。
 *     ArrayBlockingQueue
 *         看BlockingQueue类的帮助文档，其中有各个方法的区别对比列表。
 *         只有put方法和take方法才具有阻塞功能。
 *     阻塞队列与Semaphore有些相似，但也不同，阻塞队列是一方存放数据，另一方释放数据
 *     Semaphore通常则是由同一方设置和释放信号量。
 * @author LiTaiQing
 *
 */
public class BlockingQueueTest {
    public static void main(String[] args) {
        final BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(3);
        for(int i=0;i<2;i++){
            new Thread(){
                public void run(){
                    while(true){
                        try {
                            Thread.sleep((long)(Math.random()*1000));
                            System.out.println(Thread.currentThread().getName() + "准备放数据!");                            
                            queue.put(1);
                            System.out.println(Thread.currentThread().getName() + "已经放了数据，" +                             
                                        "队列目前有" + queue.size() + "个数据");
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }.start();
        }
        new Thread(){
            public void run(){
                while(true){
                    try {
                        //将此处的睡眠时间分别改为100和1000，观察运行结果
                        Thread.sleep(1000);
                        System.out.println(Thread.currentThread().getName() + "准备取数据!");
                        queue.take();
                        System.out.println(Thread.currentThread().getName() + "已经取走数据，" +                             
                                "队列目前有" + queue.size() + "个数据");                    
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();            
    }
}

import java.util.Collections;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueCommunication {
    public static void main(String[] args) {
        final Business business = new Business();
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 50; i++) {
                    business.sub(i);
                }

            }
        }).start();

        for (int i = 1; i <= 50; i++) {
            business.main(i);
        }
    }

    static class Business {

        BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
        BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);

        {
            Collections.synchronizedMap(null);
            try {
                System.out.println("代码执行...");
                queue2.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void sub(int i) {
            try {
                queue1.put(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for (int j = 1; j <= 10; j++) {
                System.out.println("sub thread sequece of " + j + ",loop of "
                        + i);
            }
            try {
                queue2.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        public void main(int i) {
            try {
                queue2.put(1);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            for (int j = 1; j <= 100; j++) {
                System.out.println("main thread sequece of " + j + ",loop of "
                        + i);
            }
            try {
                queue1.take();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}