阻塞队列BlockingQueue(JDK8)

版权声明:【分享也是一种提高】个人转载请在正文开头明显位置注明出处,未经作者同意禁止企业/组织转载,禁止私自更改原文,禁止用于商业目的。 https://blog.csdn.net/u010887744/article/details/70195270

  1. BlockingQueue(阻塞队列)是JDK5新增的线程安全的高效队列类,基于生产者-消费者模式。队列为空时,获取元素的操作等待队列变为非空;队列已满时插入操作等待队列空间可用。
  2. BlockingQueue不接受null元素,会throw NullPointerException,null用于标记poll操作的失败。
  3. BlockingQueue默认容量大小为Integer.MAX_VALUE,支持自定义容量大小。类似于Collection接口,支持remove(x),然而由于性能问题并不推荐大量使用。drainTo(c)比重复poll更高效。
  4. BlockingQueue本质上不提供close、shutdown操作用来标记“不再有元素继续被添加”,开发者可自行定义特殊元素来表示“不再有元素继续被添加”。
  5. 本文地址:http://blog.csdn.net/u010887744/article/details/70195270

方法   操作成功 一直阻塞直到处理成功 失败返回特殊值 失败抛异常
插入 add(e) true     队列已满则IllegalStateException: Queue full
offer(e) true   队列已满:false  
put(e) void 一直阻塞直到插入成功    
offer e,timeout, unit) true   插入超时:false  
addAll(c) true   部分插入异常返回false 队列已满则IllegalStateException: Queue full
移除/获取 remove() 返回被移除的元素     队列为空:抛出NoSuchElementException
remove(e) true   不存在该元素:false  
removeAll(c) 迭代remove(e),队列因此请求而改变则返回true   false  
poll() 队列头   队列为空返回null而不是抛异常  
poll(timeout,unit) 队列头   取数据超时(一直无可返回的对象):返回null  
drainTo(c):将[所有]可用元素加入集合c 集合转移数据个数      
drainTo(c,max):移除最多max个元素并将其加入集合c 集合转移数据个数      
take() 队列头 一直阻塞,直到取回数据    
removeIf(filter) JDK8可用;remove成功任何一个元素即返回true   false  
retainAll(c):数据保留 队列因此请求而改变则返回true   没有remove任何一个元素即返回false  
clear() void      
检测(取回但不移除) element() 队列头     队列为空throw NoSuchElementException
peek() 队列头   队列为空返回null  
contains(e) true   false  
containsAll(c) true   false  
isEmpty() true   false  


其他操作:
  • size():队列大小。
  • remainingCapacity():可用大小。
  • toArray():返回包含集合所有元素的数组,数组顺序和原有集合一致。返回的数组存在于新的内存空间,和原有队列的修改操作不会互相影响。
  • toArray(arr[]):待储存集合空间充足,将队列所有元素按序存于数组,并将多余元素置为null;待储存集合空间不足,将队列所有元素按序存于【新的数组】。
  • forEach(Consumer<? super String> action)、parallelStream()、spliterator().forEachRemaining、removeIf(filter)等JDK8新增特性见测试代码。
Note:
  • addAll(c)内部结构为foreach遍历add(e),所以可能部分数据插入成功,部分插入失败。
  • drainTo(c)是将队列元素添加到集合c;toArray()是将队列元素覆盖集合元素c。
  • remove(x),由于性能问题并不推荐大量使用;drainTo(c)比重复poll更高效

相关测试代码如下:

/*
 * 文件名:BlockingQueue_Study.java
 * 版权:Copyright 2007-2017 zxiaofan.com. Co. Ltd. All Rights Reserved. 
 * 描述: BlockingQueue_Study.java
 * 修改人:zxiaofan
 * 修改时间:2017年4月11日
 * 修改内容:新增
 */
package java1.util.concurrent.blockingQueue;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.function.Predicate;

import org.junit.Test;

/**
 * @author zxiaofan
 */
public class BlockingQueue_Study {
    BlockingQueue<String> blockingQueue = new LinkedBlockingQueue<String>(5); // <队列对象String>(队列容量)

    List<String> list = Arrays.asList("list1", "list2");

    /**
     * 插入操作:插入元素为null时将抛出NullPointerException.
     * 
     */
    @Test
    public void BlockingQueueInsertTest() {
        // add-AbstractQueue
        boolean add = blockingQueue.add("add"); // 插入成功:true;阻塞队列已满:抛出java.lang.IllegalStateException: Queue full
        System.out.println("add:" + add);
        boolean offer = blockingQueue.offer("offer"); // 插入成功:true;队列已满:false;
        System.out.println("offer:" + offer);
        try {
            blockingQueue.put("put"); // 无返回值;一直阻塞直到插入成功;线程被中断即Thread.interrupted()时:抛出InterruptedException
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            boolean offer_timeout = blockingQueue.offer("offer_timeout", 3, TimeUnit.SECONDS); // 插入成功:true;插入超时:false;线程被中断即Thread.interrupted()时:抛出InterruptedException
            System.out.println("offer_timeout:" + offer_timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        boolean addAll = false;
        try {
            // addAll-AbstractQueue
            addAll = blockingQueue.addAll(list); // 插入成功:true;内部结构为foreach遍历add(e),所以可能部分数据插入成功,部分插入失败
        } catch (Exception e) { // 吃掉异常
            System.err.println("addAll_Exception:" + e.getMessage());
            // e.printStackTrace();
        }
        System.out.println("addAll:" + addAll);
        System.out.println(blockingQueue.toString());
    }

    /**
     * 阻塞队列移除操作.
     * 
     */
    @Test
    public void BlockingQueueRemoveTest() {
        BlockingQueueInsertTest();
        // remove-AbstractQueue
        String remove = blockingQueue.remove(); // 移除队列头。移除成功:返回被移除的元素;队列为空:抛出NoSuchElementException
        System.out.println("remove:" + remove);
        boolean removeObj = blockingQueue.remove("offer"); // 用equals()判断两个对象是否相等。移除成功:true;不存在该元素:false
        System.out.println("removeObj:" + removeObj);
        String poll = blockingQueue.poll(); // 移除队列头。和remove()的唯一区别在于,当队列为空返回null而不是抛异常
        System.out.println("poll:" + poll);
        try {
            String poll_timeout = blockingQueue.poll(3, TimeUnit.SECONDS); // 移除成功:返回被移除的元素;移除超时(一直无可移除的对象):返回null;线程被中断抛InterruptedException
            System.out.println("poll_timeout:" + poll_timeout);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            String take = blockingQueue.take(); // 一直阻塞,直到取回数据;等待时被中断则抛出InterruptedException
            System.out.println("take:" + take);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        blockingQueue.add("list1");
        boolean removeAll = blockingQueue.removeAll(list); // Iterator<?> it = iterator();迭代remove(),只要remove成功一个且不抛异常就返回false
        System.out.println("removeAll:" + removeAll);
        System.out.println(blockingQueue.toString());
        blockingQueue.addAll(list);
        Predicate<? super String> filter = (p) -> p.startsWith("list");
        boolean removeIf = blockingQueue.removeIf(filter); // JDK8可用;remove成功任何一个元素即返回true
        System.out.println("removeIf:" + removeIf);
        System.out.println(blockingQueue.toString());
        //
        System.out.println("数据保留");
        BlockingQueueInsertTest();
        // retailAll-AbstractCollection
        boolean retainAll = blockingQueue.retainAll(list); // 队列因此请求而改变则返回true,没有remove任何一个元素即返回false
        System.out.println("retainAll:" + retainAll);
        System.out.println(blockingQueue.retainAll(Arrays.asList("retailAll")));
        System.out.println(blockingQueue.retainAll(list)); // 没有remove任何一个元素即返回false
        System.out.println(blockingQueue.toString());
        blockingQueue.clear(); // 移除所有元素,clear首先加锁fullyLock()
    }

    /**
     * 阻塞队列的cheek:element()/peek().
     * 
     */
    @Test
    public void BlockingQueueCheckTest() {
        BlockingQueueInsertTest();
        String element = blockingQueue.element(); // 取回但不移除队首元素,队列为空throw NoSuchElementException
        System.out.println("element:" + element);
        String peek = blockingQueue.peek(); // 取回但不移除队首元素,队列为空返回null
        System.out.println("peek:" + peek);
        boolean contains = blockingQueue.contains("add"); // 有一元素equals即返回true
        System.out.println("contains:" + contains);
        boolean containsAll = blockingQueue.containsAll(Arrays.asList("add", "offerNew")); // contains所有元素即返回true
        System.out.println("containsAll:" + containsAll);
        boolean isEmpty = blockingQueue.isEmpty(); // 队列无元素即返回true
        System.out.println("isEmpty:" + isEmpty);
    }

    @Test
    public void BlockingQueueOtherTest() {
        BlockingQueueInsertTest();
        // 容量
        System.out.println("size:" + blockingQueue.size());
        int remainingCapacity = blockingQueue.remainingCapacity();
        System.out.println("remainingCapacity:" + remainingCapacity);
        // 遍历
        Consumer<? super String> consumer = e -> e = e + "_New"; // 将所有元素拼接一个"_New",实际blockingQueue队列元素并为改变,因为String具有不可变性
        blockingQueue.forEach(consumer); // JDK8
        System.out.println("consumer:" + blockingQueue.toString());
        blockingQueue.forEach(e -> {
            System.out.println(e + "_New"); // 遍历每个元素拼接"_New"并打印
        });
        int sum = blockingQueue.parallelStream().filter(p -> p.length() > 4).mapToInt(p -> p.length()).sum();
        System.out.println("JDK8流处理(字符串长度大于4的元素的字符长度和):" + sum);
        blockingQueue.spliterator().forEachRemaining(e -> {
            System.out.println(e + "_FER");
        }); // forEachRemaining:JDK8迭代器默认方法,为集合所有未处理元素执行Action
        // drainTo
        // 比重复poll更高效。drainTo操作时会加锁(ReentrantLock),add操作将等待,故正如Java Doc描述drainTo(Collection c)会将[所有]可用元素加入集合c。
        int actualSize = blockingQueue.size() - blockingQueue.remainingCapacity(); // 队列实际元素个数
        List<String> listDrain = new ArrayList<String>(actualSize);
        new Thread(new Runnable() {

            @Override
            public void run() {
                blockingQueue.add("drainToNew"); // 调试时在此行加断点
            }
        }).start();
        int drainTo = blockingQueue.drainTo(listDrain); // 此行断点调试内部
        // listDrain、blockingQueue都可能有值(并非drainTo未移除所有元素,而是drainTo后又add了新元素)
        System.out.println("drainTo:" + drainTo + ",listDrain:" + listDrain.toString() + ",blockingQueue:" + blockingQueue.toString());
        BlockingQueueInsertTest();
        listDrain.clear();
        int drainToMax = blockingQueue.drainTo(listDrain, 3); // 移除最多max个元素并将其加入listDrain
        System.out.println("drainToMax:" + drainToMax + ",listDrain:" + listDrain.toString() + ",blockingQueue:" + blockingQueue.toString());
        Object[] toArray = blockingQueue.toArray(); // 返回包含集合所有元素的数组,数组顺序和原有集合一致。返回的数组存在于新的内存空间,和原有队列的修改操作不会互相影响。
        System.out.println("toArray:" + Arrays.asList(toArray).toString());
        String[] arrToArray = new String[]{"arr1", "arr2", "arr3"}; // 待储存集合空间充足,将队列所有元素按序存于数组,并将多余元素置为null
        String[] toArrayT = blockingQueue.toArray(arrToArray);
        System.out.println("toArrayT:" + Arrays.asList(toArrayT).toString());
        String[] arrToArray2 = new String[]{"arr1"}; // 待储存集合空间不足,将队列所有元素按序存于【新的数组】
        String[] toArrayT2 = blockingQueue.toArray(arrToArray2);
        System.out.println("toArrayT2:" + Arrays.asList(toArrayT2).toString());
    }
}

欢迎个人转载,但须在文章页面明显位置给出原文连接;
未经作者同意必须保留此段声明、不得随意修改原文、不得用于商业用途,否则保留追究法律责任的权利。

【 CSDN 】:csdn.zxiaofan.com
【GitHub】:github.zxiaofan.com

如有任何问题,欢迎留言。祝君好运!
Life is all about choices! 
将来的你一定会感激现在拼命的自己!

没有更多推荐了,返回首页