BlockingQueue阻塞队列

BlockingQueue

• 实现类

• Collection->Queue->BlockingQueue
• 使用场景：多线程并发处理，线程池
• Queue源码

public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

• BlockingQueue源码

public interface BlockingQueue<E> extends Queue<E> {
    boolean add(E e);
    boolean offer(E e);
    void put(E e) throws InterruptedException;
    boolean offer(E e, long timeout, TimeUnit unit)
        throws InterruptedException;
    E take() throws InterruptedException;
    E poll(long timeout, TimeUnit unit)
        throws InterruptedException;
    int remainingCapacity();
    boolean remove(Object o);
    boolean contains(Object o);
    int drainTo(Collection<? super E> c);
    int drainTo(Collection<? super E> c, int maxElements);
}

ArrayBlockingQueue

• 依赖AQS实现并发操作
• 四组API

方式	抛出异常	不抛出异常	阻塞等待	超时等待
添加	add(o)	offer(o)	put(o)	offer(o, timeout, timeunit)
移除	remove()	poll()	take()	poll(timeout, timeunit)
判断队首	element()	peek()	---	---

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;
 
class MyBlockingQueue {
    public static void main(String[] args) throws InterruptedException {
 
        // 抛出异常
//        test1();
 
        // 不抛出异常
//        test2();
 
        // 阻塞等待
//        test3();
 
        // 超时等待
        test4();
    }
 
    public static void test1() {
        // 队列大小
        ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        System.out.println(arrayBlockingQueue.add("a")); // true
        System.out.println(arrayBlockingQueue.add("b")); // true
        System.out.println(arrayBlockingQueue.add("c")); // true
//        System.out.println(arrayBlockingQueue.add("d")); // IllegalStateException队列满
 
        System.out.println(arrayBlockingQueue.element()); // 查看队首
 
        System.out.println(arrayBlockingQueue.remove()); // ture
        System.out.println(arrayBlockingQueue.remove()); // ture
        System.out.println(arrayBlockingQueue.remove()); // ture
//        System.out.println(arrayBlockingQueue.remove()); // NoSuchElementException
    }
 
    public static void test2() {
        // 队列大小
        ArrayBlockingQueue<Object> 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")); // 不跑出异常，返回false
 
        System.out.println(arrayBlockingQueue.peek());
 
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll());
        System.out.println(arrayBlockingQueue.poll()); // 不抛出异常，返回null
 
    }
 
    public static void test3() throws InterruptedException {
        // 队列大小
        ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
 
        // 没有返回值
        arrayBlockingQueue.put("a");
        arrayBlockingQueue.put("b");
        arrayBlockingQueue.put("c");
//        arrayBlockingQueue.put("d");// 会一直等
 
        System.out.println(arrayBlockingQueue.take()); // a
        System.out.println(arrayBlockingQueue.take()); // b
        System.out.println(arrayBlockingQueue.take()); // c
//        System.out.println(arrayBlockingQueue.take());// 会一直等
    }
 
    public static void test4() throws InterruptedException {
        // 队列大小
        ArrayBlockingQueue<Object> arrayBlockingQueue = new ArrayBlockingQueue<>(3);
        arrayBlockingQueue.offer("a");
        arrayBlockingQueue.offer("b");
        arrayBlockingQueue.offer("c");
        arrayBlockingQueue.offer("d", 2, TimeUnit.SECONDS);// 两秒后结束等待
 
        System.out.println(arrayBlockingQueue.poll()); // a
        System.out.println(arrayBlockingQueue.poll()); // b
        System.out.println(arrayBlockingQueue.poll()); // c
        System.out.println(arrayBlockingQueue.poll(2, TimeUnit.SECONDS)); // 两秒后结束等待，返回null
        System.out.println("over");
    }
}

SynchronousQueue同步队列

• 使用CAS实现线程的安全访问

• 构造函数，默认非公平

public SynchronousQueue() {
    this(false);
}
 
public SynchronousQueue(boolean fair) {
    // 公平：队尾匹配队头出队
    // 非公平：先入栈后匹配
    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}

• 它一种阻塞队列，其中每个 put 必须等待一个 take，反之亦然。同步队列没有任何内部容量，甚至连一个队列的容量都没有。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
 
class MySynchronousQueue {
    public static void main(String[] args) {
        // 同步队列
        BlockingQueue<String> blockingQueue = new SynchronousQueue<>();
 
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " put\t1");
                //  往queue放进去一个element以后就一直wait直到有其他thread进来把这个element取走
                blockingQueue.put("1");
                System.out.println(Thread.currentThread().getName() + " put\t2");
                blockingQueue.put("2");
                System.out.println(Thread.currentThread().getName() + " put\t3");
                blockingQueue.put("3");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Producer").start();
 
        new Thread(() -> {
            try {
                TimeUnit.SECONDS.sleep(1);
                // 取出并删除element，取不到东西他会一直等
                System.out.println(Thread.currentThread().getName() + " take\t" +blockingQueue.take());
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + " take\t" +blockingQueue.take());
                TimeUnit.SECONDS.sleep(1);
                System.out.println(Thread.currentThread().getName() + " take\t" +blockingQueue.take());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "Consumer").start();
    }
}

LinkedBlockingQueue

• 构造函数Integer.MAX_VALUE

// 默认容量
public LinkedBlockingQueue() {
    this(Integer.MAX_VALUE);
}
 
public LinkedBlockingQueue(int capacity) {
    if (capacity <= 0) throw new IllegalArgumentException();
    this.capacity = capacity;
    last = head = new Node<E>(null);
}

PriorityBlockingQueue

• 带优先级的无界阻塞队列
• 每次出队都返回优先级最高的元素，是二叉树最小堆的实现