阻塞队列和非阻塞队列(JAVA)

1.阻塞队列

1.1 代码举例

1个生产者，队列元素大小为2，三个消费者消费

public class TestQueue {
    private int queueSize = 2;
    private BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>(queueSize);

    @Test
    public void test1() throws InterruptedException {

        TestQueue testQueue = new TestQueue();
        Producer producer = testQueue.new Producer();
        Consumer consumer = testQueue.new Consumer();
        Consumer consumer2 = testQueue.new Consumer();
        Consumer consumer3 = testQueue.new Consumer();

        producer.start();
        consumer.start();
        consumer2.start();
        consumer3.start();

        Thread.sleep(500000);

    }

    class Consumer extends Thread{

        @Override
        public void run() {
            consume();
        }

        private void consume() {
            String name = Thread.currentThread().getName()+"-consumer";
            while(true){
                try {
                    System.out.println("【"+name+"】准备向队列取一个元素");
                    queue.take();
                    System.out.println("【"+name+"】从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Producer extends Thread{

        @Override
        public void run() {
            produce();
        }

        private void produce() {
            String name = Thread.currentThread().getName()+"-producer";
            while(true){
                try {
                    Thread.sleep(2000);
                    queue.put(1);
                    System.out.println("【"+name+"】向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

由上可知：
1.当队列没有元素的时候，所有线程获取元素的时候，都会进行阻塞，知道队列里有元素了才继续往下执行

1.2 LinkedBlockingQueue

基于链表的阻塞队列，同ArrayBlockingQueue类似，其内部也是维护着一个数据缓冲队列(该队列有一个链表构成)，LinkedBlockingQueue之所以能够高效的处理并发数据，是因为其内部实现采用分离锁(读写分离两个锁)，从而实现生产者和消费者操作的完全并行运行。它是一个无界队列。

2.非阻塞队列

2.1 代码举例

1个生产者，一个队列，三个消费者消费

public class TestQueue2 {

    private ConcurrentLinkedQueue<Integer> queue = new ConcurrentLinkedQueue<Integer>();
    @Test
    public void test1() throws InterruptedException {


        TestQueue2 testQueue = new TestQueue2();
        Producer producer = testQueue.new Producer();
        Consumer consumer = testQueue.new Consumer();
        Consumer consumer2 = testQueue.new Consumer();
        Consumer consumer3 = testQueue.new Consumer();

        producer.start();
        consumer.start();
        consumer2.start();
        consumer3.start();

        Thread.sleep(500000);

    }



    class Consumer extends Thread{

        @Override
        public void run() {
            consume();
        }

        private void consume() {
            String name = Thread.currentThread().getName()+"-consumer";
            Random random = new Random();
            while(true){
                try {
                    Thread.sleep(1000*(random.nextInt(5)));
                    System.out.println("【"+name+"】准备向队列取一个元素");
                    Integer poll = queue.poll();
                    System.out.println("【"+name+"】从队列取走一个元素"+poll);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Producer extends Thread{

        @Override
        public void run() {
            produce();
        }

        private void produce() {
            String name = Thread.currentThread().getName()+"-producer";
            while(true){
                try {
                    Thread.sleep(2000);
                    queue.offer(1);
                    System.out.println("【"+name+"】向队列取中插入一个元素)");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }


}

由上可知：
1.非阻塞队列，若线程从中获取元素，若没有则直接返回空，不会阻塞当前线程
2.ConcurrentLinkedQueue的API原来.size()是要遍历一遍集合的，很慢，所以尽量要避免用size而改用isEmpty()
3.若要用于生产者和消费者，则需要增加并发控制

2.2 ConcurrentLinkedQueue

是一个适用于高并发场景下的队列，通过无锁的方式，实现了高并发状态下的高性能，通常ConcurrentLikedQueue性能好于BlockingQueue。
它是一个基于连接节点的无界线程安全队列。该队列的元素遵循先进先出的原则。头是最先加入的，尾是最近加入的，该队列不允许null元素。
ConcurrentLinkedQueue重要方法：
add()和offer()都是加入元素的方法(在ConcurrentLinkedQueue中，这两个方法没有任何区别)。
poll()和peek()都是取头元素节点，区别在于前者会删除元素，后者不会

参考：
阻塞队列与非阻塞队列区别应用场景
JAVA阻塞队列LinkedBlockingQueue 以及非阻塞队列ConcurrentLinkedQueue 的区别
并发队列 ConcurrentLinkedQueue 及 BlockingQueue 接口实现的四种队列
Java并发编程：阻塞队列
java阻塞队列与非阻塞队列
LinkedBlockingQueue 和 ConcurrentLinkedQueue的用法及区别
如何理解线程安全的ConcurrentLinkedQueue队列的底层源码实现
ConcurrentLinkedQueue非阻塞队列