blockingqueue学习笔记

一。接口blockingqueue

      1>BlockingQueue是一种特殊的queue，特殊性如下：
      若blockingQueue是空的，从该队列中取东西的操作将会被阻断进入等待状态，知道blockingqueue进了新货才会被唤醒。
      若blockingQueue是满的，向该队列中村东西的操作也会被阻断进入等待状态，直到blockingqueue有了空间才会被唤醒
     2>BlockingQueue主要有以下方法

    add(Object)方法：如果没满返回true，如果满了抛出illegalStateException
     offer(Object)方法：如果没满返回true，如果满了返回false
     put(Object)方法：如果没满返回true，如果满了阻塞直到有新空间
     poll(time)方法：如果为空阻塞，如果一直为空time时间后返回null
     take()方法：如果为空一直阻塞到不为空

二。BlockingQueue的几种实现

    1>ArrayBlockingQueue

          构造器必须带长度，可以规定访问策略是否为FIFO(先入先出) 默认就是FIFO的，fair参数如果是false的话，貌似是非线程安全的（待确认）

    2>LinkedBlockingQueue

           构造器可以不定义大小，也可以定义。若不带大小，最大为Integer.MAX_VALUE决定

    1>、2>相比，2的数据吞吐量要大，但在线程数量很大是，其性能的可预见性要低于1

    3>PriorityBlockingQueue。

            它最大的特点是

            可以自己定义一个比较器，个性化为队列的顺序排序。用法很简单。

    4>SynchronousQueue

            这个queue比较特殊，对其操作必须是放和取交替完成的。用到再研究

三。BlockingDeque

      deque一般是双端队列，会比queue多addFirst、addLast、等方法，具体方法参考queue。

四。用BlockingQueue来实现Producer和Consumer的例子，代码如下：

public class BlockingQueueTest {
    public static class Basket {
        BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);
        public void produce() throws InterruptedException {
            basket.put("An apple");
        }
        public int getSize(){
            return basket.size();
        }
        public String consume() throws InterruptedException {
            return basket.take();
        }
    }

    public static void testBasket() {
        final Basket basket = new Basket();
        class Consumer implements Runnable {

            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("消费苹果"+(basket.getSize()+1)+"中");
                        basket.consume();
                        System.out.println("消费"+basket.getSize()+"苹果");
                        Thread.sleep(1000);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        class Producer implements Runnable {


            @Override
            public void run() {
                try {
                    while (true) {
                        System.out.println("生产"+(basket.getSize()+1)+"苹果中");
                        basket.produce();
                        System.out.println("生产"+basket.getSize()+"苹果");
                        Thread.sleep(300);
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        ExecutorService service=Executors.newCachedThreadPool();
        Producer producer=new Producer();
        Consumer consumer=new Consumer();
        service.submit(producer);
        service.submit(consumer);
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        service.shutdownNow();
    }
    public static void main(String[] args) {
        testBasket();
    }
}