BlockingQueue阻塞队列

1.什么是阻塞队列

• 写入：当队列满之后，阻塞等待
• 取：当队列为空，阻塞等待生产者创建

2.什么时候使用

• 多线程并发处理，线程池
  

API	抛异常	不抛异常	阻塞等待	设置等待时间
放	add	offer	put(“a”)	offer(“a”, 2, TimeUnit.SECONDS))
取	remove	poll	take()	poll(2,TimeUnit.SECONDS)
取第一个	element	peek

public class QueueDemo {

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

         test4();

    }

    /*抛出异常*/
    public static  void test1(){
        //设置一个初始值为3的队列
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);

        System.out.println(arrayBlockingQueue.add("a"));
        System.out.println(arrayBlockingQueue.add("b"));
        System.out.println(arrayBlockingQueue.add("c"));

        //java.lang.IllegalStateException: Queue full
        //System.out.println(arrayBlockingQueue.add("d"));

        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());
        System.out.println(arrayBlockingQueue.remove());

        //java.util.NoSuchElementException
        //System.out.println(arrayBlockingQueue.remove());

        //java.util.NoSuchElementException
        //System.out.println(arrayBlockingQueue.element());
    }

    /*有返回值，不抛异常*/
    public static  void test2(){
        //设置一个初始值为3的队列
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);

        System.out.println(arrayBlockingQueue.offer("a"));
        System.out.println(arrayBlockingQueue.offer("b"));
        System.out.println(arrayBlockingQueue.offer("c"));

        System.out.println(arrayBlockingQueue.offer("d"));

        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());

        System.out.println(arrayBlockingQueue.poll());

        System.out.println(arrayBlockingQueue.peek());
    }

    /*阻塞：一直等，死死的等*/
    public static  void test3() throws InterruptedException {
        //设置一个初始值为3的队列
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);

        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");

        arrayBlockingQueue.put("d");
        System.out.println("==================");
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());
        System.out.println(arrayBlockingQueue.take());

        System.out.println(arrayBlockingQueue.take());

    }

    /*设置一定的等待时间,超过之后，继续执行*/
    public static  void test4() throws InterruptedException {
        //设置一个初始值为3的队列
        ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(3);

        System.out.println(arrayBlockingQueue.offer("a", 2, TimeUnit.SECONDS));
        System.out.println(arrayBlockingQueue.offer("b", 2, TimeUnit.SECONDS));
        System.out.println(arrayBlockingQueue.offer("c", 2, TimeUnit.SECONDS));

        System.out.println(arrayBlockingQueue.offer("d", 2, TimeUnit.SECONDS));
        System.out.println("==================");
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));

        System.out.println(arrayBlockingQueue.poll(2,TimeUnit.SECONDS));
        System.out.println("==================");

    }
}

3.SynchronousQueue同步队列

• 同步队列：队列只能有一个元素，放进去一个，放第二个必须等到第一个取出

/*
* 同步队列：不存储元素，放进去一个，放第二个必须等到第一个取出
* 类似于：BlockingQueue的容量为1，方法用put 、take
* 特性：put\take必须在两个不同线程中执行
* */
public class SynchronousQueueDemo {

    public static void main(String[] args) {
        SynchronousQueue<String> synchronousQueue = new SynchronousQueue();

        new Thread(()->{
            try {
                synchronousQueue.put("1");
                System.out.println(Thread.currentThread().getName()+" put 1");
                synchronousQueue.put("2");
                System.out.println(Thread.currentThread().getName()+" put 2");
                synchronousQueue.put("3");
                System.out.println(Thread.currentThread().getName()+" put 3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"A").start();

        new Thread(()->{
            try {
                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName()+" get "+synchronousQueue.take());

                TimeUnit.SECONDS.sleep(5);
                System.out.println(Thread.currentThread().getName()+" get "+synchronousQueue.take());

                TimeUnit.SECONDS.sleep(2);
                System.out.println(Thread.currentThread().getName()+" get "+synchronousQueue.take());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"B").start();
    }

}