BlockingQueue常用方法add、off、put、take、poll使用说明

1.BlockingQueue的定义

首先将BlockingQueue提供的方法的含义解释如下：

import java.util.Collection;
import java.util.Queue;
import java.util.concurrent.TimeUnit;

public interface BlockingQueue<E> extends Queue<E> {
    /**
     * 1.在不违反容量限制的情况下将指定元素插入队列，成功则立即返回true。
     * 2.如果没有空间则抛出IllegalStateException异常
     * 3.当使用容量受限时，通常使用offer
     */
    boolean add(E e);

    /**
     * 1.在不违反容器限制的情况下降元素插入队列，成功则返回true
     * 2.如果没有可用空间则返回false
     * 3.当使用容器首先是，此方法比add更可取，因为add需要抛出异常
     */
    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;

    /**
     * 返回此队列在理想情况下可以不阻塞的接受元素数或者（Integer.MAX_VALUE）如果没有限制
     */
    int remainingCapacity();

    /**
     * 从队列中删除指定的元素
     */
    boolean remove(Object o);

    /**
     * 如果此队列包含指定元素则返回true
     */
    public boolean contains(Object o);

    /**
     * 从队列中删除所有可用元素并将它们添加到指定集合中
     */
    int drainTo(Collection<? super E> c);

    /**
     * 从队列中删除指定数量的可用元素，并将它们添加到指定集合中
     */
    int drainTo(Collection<? super E> c, int maxElements);
}

2.测试代码如下

package com.leo.demo;

import org.junit.Test;

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

/**
 * @ClassName: BlockingQueueTest
 * @Description: ${description}
 * @Author: leo825
 * @Date: 2020-06-18 21:51
 * @Version: 1.0
 */
public class BlockingQueueTest {

    BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<String>(3);

    /**
     * 将元素插入队列中，超出容量则抛异常
     */
    @Test
    public void addTest() {
        boolean result;
        int queueSize = 3;
        for (int i = 0; i < queueSize; i++) {
            String valStr = String.valueOf(i);
            result = blockingQueue.add(valStr);
            if (result) {
                System.out.println("add添加[" + valStr + "]成功了");
            }
        }
        System.out.println(blockingQueue.toString());
        //添加容量之外的字符串
        String str0 = "666";
        result = blockingQueue.add(str0);
        if (result) {
            System.out.println("add添加[" + str0 + "]成功了");
        } else {
            System.out.println("add添加[" + str0 + "]失败了");
        }
    }

    /**
     * 将元素插入队列中，超出容量不抛异常
     */
    @Test
    public void offerTest() {
        boolean result;
        int queueSize = 3;
        for (int i = 0; i < queueSize; i++) {
            String valStr = String.valueOf(i);
            result = blockingQueue.offer(valStr);
            if (result) {
                System.out.println("add添加[" + valStr + "]成功了");
            }
        }
        System.out.println(blockingQueue.toString());
        //添加容量之外的字符串
        String str0 = "666";
        result = blockingQueue.offer(str0);
        if (result) {
            System.out.println("add添加[" + str0 + "]成功了");
        } else {
            System.out.println("add添加[" + str0 + "]失败了");
        }
    }


    /**
     * 将元素插入队列中，超出容量阻塞，常用配合take来做生产者消费者模型
     */
    @Test
    public void putTest() throws InterruptedException {
        int queueSize = 3;
        for (int i = 0; i < queueSize; i++) {
            String valStr = String.valueOf(i);
            blockingQueue.put(valStr);
            System.out.println("add添加[" + valStr + "]成功了");

        }
        System.out.println(blockingQueue.toString());
        //添加容量之外的字符串
        String str0 = "666";
        blockingQueue.put(str0);
        System.out.println("add添加[" + str0 + "]成功了");
    }


    /**
     * 获取队列的队头元素并删除，如果未获取到则阻塞队列直到获取到，常用配合put来做生产者消费者模型
     */
    @Test
    public void takeTest() throws InterruptedException {
        int queueSize = 3;
        for (int i = 0; i < queueSize; i++) {
            String valStr = String.valueOf(i);
            blockingQueue.put(valStr);
            System.out.println("add添加[" + valStr + "]成功了");

        }
        System.out.print("take()之前：");
        System.out.println(blockingQueue.toString());
        //添加容量之外的字符串
        String str0;
        str0 = blockingQueue.take();
        System.out.println("take获取[" + str0 + "]成功了");
        System.out.print("take()之后：");
        System.out.println(blockingQueue.toString());
        str0 = blockingQueue.take();
        System.out.println("take获取[" + str0 + "]成功了");
        System.out.print("take()之后：");
        System.out.println(blockingQueue.toString());
        str0 = blockingQueue.take();
        System.out.println("take获取[" + str0 + "]成功了");
        System.out.print("take()之后：");
        System.out.println(blockingQueue.toString());
        //多取一个则阻塞了
        str0 = blockingQueue.take();
        System.out.println("take获取[" + str0 + "]成功了");
        System.out.print("take()之后：");
        System.out.println(blockingQueue.toString());
    }

    /**
     * 获取队列的队头元素并删除，如果未获取到直接返回null
     */
    @Test
    public void poolTest() throws InterruptedException {
        int queueSize = 3;
        for (int i = 0; i < queueSize; i++) {
            String valStr = String.valueOf(i);
            blockingQueue.put(valStr);
            System.out.println("add添加[" + valStr + "]成功了");

        }
        System.out.print("poll()之前：");
        System.out.println(blockingQueue.toString());
        //添加容量之外的字符串
        String str0;
        str0 = blockingQueue.poll();
        System.out.println("poll获取[" + str0 + "]成功了");
        System.out.print("poll()之后：");
        System.out.println(blockingQueue.toString());
        str0 = blockingQueue.poll();
        System.out.println("poll获取[" + str0 + "]成功了");
        System.out.print("poll()之后：");
        System.out.println(blockingQueue.toString());
        str0 = blockingQueue.poll();
        System.out.println("poll获取[" + str0 + "]成功了");
        System.out.print("poll()之后：");
        System.out.println(blockingQueue.toString());
        //多取一个则阻塞了
        str0 = blockingQueue.poll();
        System.out.println("poll获取[" + str0 + "]成功了");
        System.out.print("take()之后：");
        System.out.println(blockingQueue.toString());
    }
}