[JUC] 3.3 ArrayBlockingQueue 和 LinkedBlockingQueue

/**
 * ArrayBlockingQueue：是一个底层用数组（准确的说是一个循环数组（可以类比一个圆环），所有的下标在到达最大长度时自动从0继续开始。）实现的有界阻塞队列，有界是指他的容量大小是固定的，不能扩充容量，在初始化时就必须确定队列大小。
 *                    它通过可重入的独占锁 ReentrantLock 来控制并发，Condition 来实现阻塞。
 * 其主要的方法为：
 * 1.取数据：
 *      take()：首选，当队列为空时阻塞。
 *      poll()：弹出队顶元素，队列为空时，返回空。
 *      peek()：和 poll 类似，返回队顶元素，但顶元素不弹出。队列为空时返回 null。
 *      remove(Object o)：移除某个元素，队列为空时抛出异常。成功移除返回 true。
 * 2.添加数据：
 *      put()：首选，队满时阻塞。
 *      add()：插入元素到队尾，插入成功返回 true，没有可用空间抛出异常 IllegalStateException。
 *      offer()：队满时返回 false。（插入元素到队尾，插入成功返回 true，否则返回 false。）
 */
public class _06_T_ArrayBlockingQueue {

    static BlockingQueue<String> aBQ = new ArrayBlockingQueue<>(10);

    static Random r = new Random();

    public static void main(String[] args) throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            aBQ.put("a" + i);
        }

        //满了时，会阻塞
        aBQ.put("aaa");

        //add(E e)：插入元素到队尾，插入成功返回 true，没有可用空间抛出异常 IllegalStateException。
//        aBQ.add("aaa");

        //offer(E e)：插入元素到队尾，插入成功返回 true，否则返回 false。
//        boolean offer = aBQ.offer("aaa");
//        aBQ.offer("aaa",1, TimeUnit.SECONDS);

        System.out.println(aBQ);
    }
}

//设置容量为 Integer.MAX
public LinkedBlockingQueue()；   

//设置指定容量
public LinkedBlockingQueue(int capacity)；  

//穿入一个容器，如果调用该构造器，容量默认也是 Integer.MAX_VALUE
public LinkedBlockingQueue(Collection<? extends E> c)；  

/**
 * 下面的程序是 Java 提供的生产者、消费者模式的阻塞式的一种实现。
 * LinkedBlockingQueue：是一个底层用单向链表实现，可以是有界的也可以是无界的（Integer.MAX_VALUE）阻塞队列，
 *                     采用 ReentrantLock 来控制并发，添加采用的是 putLock，移除采用的则是 takeLock，使用两个独占锁来控制消费和生产。
 * 其主要的方法为：
 * 1.取数据：
 *      take()：首选，当队列为空时阻塞。
 *      poll()：弹出队顶元素，队列为空时，返回空。
 *      peek()：和 poll 类似，返回队顶元素，但顶元素不弹出。队列为空时返回 null。
 *      remove(Object o)：移除某个元素，队列为空时抛出异常。成功移除返回 true。
 * 2.添加数据：
 *      put()：首选，队满时阻塞。
 *      add()：插入元素到队尾，插入成功返回 true，没有可用空间抛出异常 IllegalStateException。
 *      offer()：队满时返回 false。（插入元素到队尾，插入成功返回 true，否则返回 false。）
 *
 * 3.判断队列是否为空：size() 方法会遍历整个队列，时间复杂度为 O(n)，所以最好选用 isEmtpy()。
 */
public class _05_T_LinkedBlockingQueue {

    static BlockingQueue<String> lBQ = new LinkedBlockingQueue<>();

    static Random r = new Random();

    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    //put()：首选，队满时阻塞。
                    lBQ.put("a" + i);
                    TimeUnit.MILLISECONDS.sleep(r.nextInt(1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "p1").start();

        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                for (; ; ) {//是循环，for(;;) 指令少，不占用寄存器，而且没有判断跳转，比 while(xx) 好。
                    try {
                        System.out.println(Thread.currentThread().getName() + " take -" + lBQ.take());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "c" + i).start();
        }
    }
}