阻塞队列

阻塞队列的简介

阻塞队列（BlockingQueue）是一个支持两个可以进行阻塞插入和阻塞移除的附加方法的队列。
1）阻塞插入：当队列满后，队列会阻塞（拒绝）插入元素，直到队列不满。
2）阻塞移除：当队列为空时，队列会阻塞（拒绝）移除元素，直到队列里有元素。

jdk里面的其中阻塞队列的实现

ArrayBlockingQueue：由数组结构组成的有界阻塞队列 （常用）
LinkedBlockingQueue：由链表结构组成的有界阻塞队列  （常用）
PriorityBlockingQueue：支持优先级排序的无界阻塞队列
DelayQueue：使用优先级队列实现的无界阻塞队列
SynchronousQueue：每次只存一个元素，只有这个元素被移除了才能存入另一个元素
LinkedTransferQueue：由链表结构组成的无界阻塞队列
LinkedBlockingDeque：由链表结构组成的双向阻塞队列

阻塞队列的四组方法

ArrayBlockingQueue的代码验证

public class BlockingQueueDemo {

//    ArrayBlockingQueue:
//    LinkedBlockingQueue : 有界，最大值为Integer.maxValue()
//    SynchronousQueue  : 不存储元素的阻塞队列，也即是单个元素的队列

    public static void main(String[] args) throws InterruptedException {

        ArrayBlockingQueue<String> strings = new ArrayBlockingQueue<>(3);

//        1. 抛出异常版
        /*System.out.println(strings.add("A"));
        System.out.println(strings.add("B"));
        System.out.println(strings.add("C"));
        //System.out.println(strings.add("D")); //java.lang.IllegalStateException: Queue full
        System.out.println(strings.element());  //弹出第一个元素 : A
        System.out.println(strings.remove());
        System.out.println(strings.remove());
        System.out.println(strings.remove());
        //System.out.println(strings.remove()); //ava.util.NoSuchElementException*/
//       2. 不丢异常，插入失败返回boolean类型，获取空队列得到null
        /*System.out.println(strings.offer("A"));
        System.out.println(strings.offer("B"));
        System.out.println(strings.offer("C"));
        System.out.println(strings.offer("D"));// false
        System.out.println(strings.poll());
        System.out.println(strings.poll());
        System.out.println(strings.poll());
        System.out.println(strings.poll()); //null*/
//       3. 一直等待，程序不停止，威力大大的
        /*strings.put("A");
        strings.put("B");
        strings.put("C");
        //strings.put("D"); //一直堵着，程序不停，一直等
        strings.take();
        strings.take();
        strings.take();
        strings.take();  //一直堵着，等忘队列里面加元素*/
//       4. 超时退出
        /*strings.offer("A",1, TimeUnit.SECONDS);
        strings.offer("B",1, TimeUnit.SECONDS);
        strings.offer("C",1, TimeUnit.SECONDS);
        //strings.offer("D",1, TimeUnit.SECONDS); //等待1s后还是满的话就退出
        strings.poll(1, TimeUnit.SECONDS);
        strings.poll(1, TimeUnit.SECONDS);
        strings.poll(1, TimeUnit.SECONDS);
        strings.poll(1, TimeUnit.SECONDS); //等待1S，还是为null的话就退出
*/
    }
}

SynchronousQueue的代码验证

//SynchronousQueue只能存一个,只有拿走了才能存另一个
public class SynchronousQueueDemo {

    public static void main(String[] args) {

        SynchronousQueue<Object> objects = new SynchronousQueue<>();

        new Thread(() -> {
            //System.out.println(Thread.currentThread().getName()+"\t put...");
            try {
                System.out.println("1  insert");
                objects.put("1");
                System.out.println("2 insert");
                objects.put("2");
                System.out.println("3 insert");
                objects.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"AAA").start();

        new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"\t put...");
            try {
                TimeUnit.SECONDS.sleep(3);
                System.out.println("1 get : " + objects.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println("2 get : " + objects.take());
                TimeUnit.SECONDS.sleep(3);
                System.out.println("3 get : " + objects.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"BBB").start();
    }
}