阻塞队列 BlockingQueue

BlockingQueue原理

---

这个BlockingQueue是个接口，BlockingQueue 通常用于一个线程生产对象，而另外一个线程消费这些对象的场景。下图是对这个原理的阐述：

用于生产者消费者模型，那就是多个线程可以操作生产，多个线程可以操作消费，如果生产过快大于队列的长度的话，会不让它生产了，让它阻塞。消费过快，也是同样的道理。

BlockingQueue的方法

---

但是由于应用的方法不同，你也可以不使用阻塞的那种方式，

\	抛异常	待定值	阻塞	超时
插入	add(o)	offer(o)	put(o)	offer(o,timeout,timeunit)
移除	remove(o)	poll(o)	take(o)	poll(o,timeout,timeunit)
检查	element(o)	peek(o)

四组不同的行为方式解释：

抛异常：如果试图的操作无法立即执行，抛一个异常。
特定值：如果试图的操作无法立即执行，返回一个特定的值(常常是 true / false)。
阻塞：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行。
超时：如果试图的操作无法立即执行，该方法调用将会发生阻塞，直到能够执行，但等待时间不会超过给定值。返回一个特定值以告知该操作是否成功(典型的是 true / false)。

BlockingQueue的实现

---

● ArrayBlockingQueue
● DelayQueue
● LinkedBlockingQueue
● PriorityBlockingQueue
● SynchronousQueue

Demo

---

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

public class Main1 {
    public static void main(String[] args) {
        BlockingQueue<Integer> bq = new ArrayBlockingQueue<Integer>(1024);
        Producer producer = new Producer(bq);
        Consumer consumer = new Consumer(bq);
        Thread t1 = new Thread(producer);
        Thread t2 = new Thread(consumer);

        t1.start();
        t2.start();


    }
}

class Producer implements Runnable {
    private BlockingQueue<Integer> blockingQueue = null;

    public Producer() {
    }

    public Producer(BlockingQueue<Integer> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        try {

            Thread.sleep(1000);
            blockingQueue.put(1);
            Thread.sleep(1000);
            blockingQueue.put(4);
            Thread.sleep(1000);
            blockingQueue.put(555);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Consumer implements Runnable {
    private BlockingQueue<Integer> blockingQueue = null;

    public Consumer() {
    }

    public Consumer(BlockingQueue<Integer> blockingQueue) {
        this.blockingQueue = blockingQueue;
    }

    @Override
    public void run() {
        try {
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
            System.out.println(blockingQueue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

结果

---

在运行的过程中，明显有阻塞的过程。如果将sleep()的时间设置的更长一些，这个阻塞的效果会更加明显。