Java并发学习（七）并发容器

最新推荐文章于 2021-08-28 17:30:37 发布

沉梦昂志1995

最新推荐文章于 2021-08-28 17:30:37 发布

阅读量462

点赞数

分类专栏：并发编程

本文链接：https://blog.csdn.net/cai13070139328/article/details/99697425

版权

并发编程专栏收录该内容

9 篇文章 0 订阅

订阅专栏

Java平台类库包含了大量的并发基础构建模块，包括线程安全的容器类以及各种用于协调多个相互协作的线程控制流的同步工具类(Synchronizer)，学习这些基础模块不仅能提高并发编程的能力，更可以从中看到Doug Lea等大师的设计思想。

同步容器类

同步容器类包括Vector、Hashtable以及它们的子类，还有通过Collections.synchronizedXxx的一些工厂方法创建的同步封装器类。对于这类同步容器类，它们是线程安全的，但是它们实现线程安全的方式是：将它们的状态封装起来，对每个公有方法使用synchronized关键字进行同步（同步方法，串行化）。

当多个线程共同使用这些方法就相当于是串行使用的，效率必然很糟糕。另外我们虽然说同步容器类是线程安全的，但是有时候需要额外的加锁机制来保护复合操作，包括迭代（遍历容器元素）、跳转（找到当前元素的下一个元素）、条件运算（比如检查Map是否存在K）。当其他线程并发修改容器的时候，这些复合操作就会出现问题。

public static Object getLast(Vector list) {
        int lastIndex = list.size()-1;
        return list.get(lastIndex);
}
    public static Object deleteLast(Vector list) {
        int lastIndex = list.size()-1;
        return list.remove(lastIndex);
}

上述代码定义了两个方法：getLast和deleteLast，它们都有两个操作先取值，再运行；每个方法都首先获取数组大小，在通过结果执行操作。这些方法在线程安全方面是没有问题的，但是试想如果同时有两个线程在操作同一个Vector，A线程调用了getLast方法，执行完第一句语句获取了数组大小时，B线程调用的deleteLast方法已经执行删除，数组大小减少1，A线程再执行list.get(lastIndex)语句时就会抛出ArrayIndexOutOfBoundsException异常。

这种情况下Vector仍然是线程安全的，但抛出异常并不是调用者想看到的结果。因此需要加上额外的复合操作，如加锁：

public static Object getLast(Vector list) {
        synchronized (list) {
            int lastIndex = list.size() - 1;
            return list.get(lastIndex);
        }
}
public static Object deleteLast(Vector list) {
        synchronized (list) {
            int lastIndex = list.size() - 1;
            return list.remove(lastIndex);
        }
}

然而，这样虽然避免了程序出现意想不到的结果，但是也大大的降低了程序的并发性，因此不是很好的策略。

并发容器

因为同步容器类存在的并发性能问题，所以Java提供了大量的并发容器来改进同步容器的性能，这些并发容器位于java.util.concurrent包中，通过并发容器代替同步容器，可以极大的提高伸缩性并降低风险。

1、并发散列表ConcurrentHashMap

ConcurrentHashMap是线程安全且高效的HashMap，它也是一个基于散列表的Map，它使用了一种粒度更小的加锁机制来实现更大程度的共享(Java7为分段锁机制、Java8为散列节点桶锁)。ConcurrentHashMap的结构和HashMap基本相同,由数组+链表+红黑树组成,只是在并发上面做了很多处理。

线程不安全的HashMap：

在Java7及之前时HashMap采用的头插法，并发执行其put操作时有可能导致HashMap的Entry链表形成环形数据结构，Entry节点的下一个next节点永不为空，从而导致死循环获取Entry节点。

虽然在Java8中HashMap改为尾插法，避免了死循环的问题，但是由于没加锁其线程安全性还是无法得到保障，详见这篇文章。

效率低下的Hashtable：

Hashtable容器使用synchronized锁住整个哈希表来保证线程安全，在线程竞争激烈的时候几乎每个线程都会被阻塞，这样导致Hashtable的效率非常低下，这是导致Hashtable不适用并发的主要原因。

还有一个原因，可以看出Hashtable是不满足驼峰命名法的，这对于大多数程序员来说是难以接受的，很容易出现错误的代码。

ConcurrentHashMap的实现原理：

基于Java8来说，ConcurrentHashMap采用的更小粒度的锁---散列节点桶锁，在保证线程安全的前提下，实现了更大程度的并发和共享；其数组、链表+红黑树的设计也是非常精妙的，为了彻底弄懂它的设计思路，值得一步步对其源码进行分析，详细的源码分析可见这篇文章ConcurrentHashMap底层原理

2、并发队列ConcurrentLinkedQueue

在并发编程中，有两种方式实现一个线程安全的队列：

使用阻塞算法的队列：用一个锁(入队/出队同一把锁)或者两个锁(入队/出队用不同的锁)来实现线程安全
使用非阻塞算法的队列：使用乐观的循环CAS来实现线程安全

并发队列ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部是队列中时间最长的元素。队列的尾部是队列中时间最短的元素。新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。其主要方法如下：

当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素。它采用CAS算法来实现，保证内存一致性效果，即当存在其他并发 collection 时，将对象放入ConcurrentLinkedQueue之前的线程中的操作happen-before随后通过另一线程从ConcurrentLinkedQueue访问或移除该元素的操作。

1.ConcurrentLinkedQueue的结构

要想先学习ConcurrentLinkedQueue自然而然得先从它的节点类看起，明白它的底层数据结构。

public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
        implements Queue<E>, java.io.Serializable {

    private static class Node<E> {
        volatile E item;
        volatile Node<E> next;
		.......
    }

    private transient volatile Node<E> head;

    private transient volatile Node<E> tail;

    public ConcurrentLinkedQueue() {
        head = tail = new Node<E>(null);
    }
    .....
}

ConcurrentLinkedQueue继承自AbstractQueue抽象类，由head节点和tail节点组成，每个节点Node由节点元素(item)和指向下一个节点(next)的引用组成，节点与节点之间构成链式队列。

默认初始化情况下head节点和tail节点指针会指向一个item域为null的节点,head和tail指向同一个节点Node0，该节点item域为null,next域为null，此时ConcurrentLinkedQueue状态如下图所示：

2.入队列

入队列就是将入队的节点添加到入队列的尾部。在分析源码之前可以用一个比较形象入队的例子来帮助理解入队列过程。

对于图中过程的解释如下：

添加元素1，此时head==tail节点且它们的next节点为null，更新队列的tail（或head）节点的next节点为元素1，此时head节点等于tail节点且它们的next节点均指向节点1
添加元素2，此时tail节点的next节点不为null，首先设置节点1的next节点为元素2，然后更新tail节点使其指向节点2
添加元素3，设置tail节点的next节点为元素3节点
添加元素4，设置节点3的next节点为元素4，然后更新tail节点使其指向节点4

通过观察入队的过程，可以将入队过程概括为：将入队节点设置为当前队尾节点的下一个节点；更新tail节点，若tail节点的next节点不为空，则将入队结点设置为tail节点，如果tail节点的next节点为空，则将入队结点设置为tail节点的next节点。

需要注意的是：tail节点并不一定总是指向队列的最后一个节点，它可能指向最后一个节点的前一个节点。

入队列源码分析：

ConcurrentLinkedQueue的入队使用的是其offer方法，将指定元素插入此队列的尾部。

    public boolean offer(E e) {
        if (e == null) throw new NullPointerException();
         //入队前创建新的入队节点
        final Node<E> newNode = new Node<E>(e);
        //死循环入队，不成功反复入队
        //t为指向tail节点的引用，p表示队列的尾结点，默认等于tail
        for (Node<E> t = tail, p = t;;) {
            Node<E> q = p.next;
            //p的next节点q为空，说明p是当前队列的尾结点
            if (q == null) {
            //CAS将入队的新节点设置为p节点的next节点；若此时p的next不为空，
            //或CAS失败，都表示有其他线程更新了尾结点，需要重新获取队列尾结点
                if (p.casNext(null, newNode)) {
          //若成功更新尾结点为入队的新节点，判断p节点是否等于tail节点
                    if (p != t) 
     //若不等于，说明tail节点后至少有p节点和新增节点2个节点，则需要更新tail为当前尾结点
                        casTail(t, newNode);  // Failure is OK.
     //此处Failure is OK意思是失败是无关紧要的，CAS失败代表其他线程已经更新了tail节点
                    return true;
                }
            }
            else if (p == q)
                p = (t != (t = tail)) ? t : head;//代码1
            else
                p = (p != t && t != (t = tail)) ? t : q;//代码2
        }
    }

在上述代码中，可以看出代码1和代码2都有t != (t = tail)语句，所以先对此语句进行分析，在多线程环境下t != (t = tail)这个操作并非一个原子操作，有这样一种情况：

如图，假设线程A此时读取了变量t，线程B刚好在这个时候offer一个Node节点后，此时会修改tail指针,那么这个时候线程A再次执行t=tail时t会指向另外一个节点，很显然线程A前后两次读取的变量t指向的节点不相同，即t != (t = tail)为true；

那么对于代码1 p = (t != (t = tail)) ? t : head 而言，当p == q时且t != (t = tail)为false时，说明p和p的next节点都为空，表示这个队列刚刚初始化，正准备添加节点，所以需要返回head节点；而当t != (t = tail)为true时，表明tail节点已经变动更新为尾结点，所以返回当前的尾结点t。

同理对于代码2 p = (p != t && t != (t = tail)) ? t : q ，当 p==t 且q != null时，说明p的next节点存在且不为空，就短路了判断语句，使得p等于p的next节点q；而当p != t && t != (t = tail)时，说明tail已经变动更新为尾结点，以返回当前的尾结点t。

综上，这两行代码的唯一目的就是为了定位到队列真正的尾结点，由于tail节点不总是尾结点，所以每次入队需要通过tail节点来找到真正的尾结点；尾结点可能是tail节点，也可能是tail的next节点。此时该行代码的执行结果为p和t最新的t指针指向了同一个节点，并且此时t也是队列真正的尾节点。那么，现在已经定位到队列真正的队尾节点，就可以执行offer操作了。

3.出队列

出队列的过程与入队列类似，从队列里返回一个元素，并清空该节点对元素的引用。

由图中可以看出，并不是每次出队都会更新head节点，当head节点里有元素时，直接弹出head节点的元素，而不会更新head节点；当head节点里没有元素时(item == null)，出队操作才会更新head节点；

这跟每次入队不一定更新tail节点是一样的道理，具体过程如下：

节点1出队，此时head的item为null，更新head结点，返回节点1的item，head指向节点2；
节点2出队，此时head的item不为null，将节点2的item设置为null，再直接返回节点2(head)的item，head仍然指向节点2；

所以同样的，head节点并不一定是指向队列的第一个有效节点，它可能指向有效节点的前一个节点。

出队列源码分析：

ConcurrentLinkedQueue的入队使用的是其poll方法，获取并移除此队列的头，如果此队列为空，则返回 null。

    public E poll() {
        restartFromHead:
        for (;;) {
            for (Node<E> h = head, p = h, q;;) {
                E item = p.item;//获取p节点的元素
          //如果p节点的元素不为空，使用CAS设置p节点引用的元素为null
                if (item != null && p.casItem(item, null)) {
      //如果p节点不是h节点，表示表头发生了变化，将p节点的下一个节点设置为head节点
                    if (p != h) 
                        updateHead(h, ((q = p.next) != null) ? q : p);
                    return item;  
                }
       //如果上个条件不成立并且表头节点的next节点q为null，那么此时队列只
       //有一个为null的节点，调用updateHead方法更新表头节点为p，然后返回null
                else if ((q = p.next) == null) {
                    updateHead(h, p);
                    return null;
                }
        //以上条件均不成立并且p==q，跳转到restartFromHead标记重新执行
                else if (p == q)
                    continue restartFromHead;
                else
                    p = q;
            }
        }
    }

首先获取头节点的元素，然后判断头节点元素是否为空，如果为空，表示另外一个线程已经进行了一次出队操作将该节点的元素取走，如果不为空，则使用 CAS 的方式将头节点的引用设置成 null，如果 CAS 成功，则直接返回头节点的元素，如果不成功，表示另外一个线程已经进行了一次出队操作更新了 head 节点，导致元素发生了变化，需要重新获取头节点。

4.HOPS的设计意图

对于上述代码你也会疑惑，为什么不直接使head永远指向头结点，tail永远作为队列的尾结点，这样实现起来好理解的多，以入队为例，这样做的代码即为：

    public boolean offer(E e) {
        if (e == null)
            throw new NullPointerException();
        Node<E> n = new Node<E>(e);
        for (;;) {
            Node<E> t = tail;
            if (t.casNext(null, n) && casTail(t, n)) 
                return true;            
        }
    }

这样做的确是可行的，但是这样做有一个缺点，如果有大量的入队操作，每次都要执行CAS进行tail的更新，当次数足够多时对性能将会是很大的损耗。

如果能减少CAS更新的操作，就能提升入队的效率，所以Doug Lea大师使用HOPS变量(上述中hops==1)作为间隔次数来控制tail节点的更新频率，每间隔HOPS(1)次（tail和队尾节点的距离为1）时才利用CAS更新tail为尾结点，对head的更新也是同样的道理。

虽然，这样设计会使得每次入队时从tail定位到队尾节点的时间变长，但总体来说仍能提高入队的效率；因为本质上来说，它是通过增加volatile变量的读操作时间来换取对volatile变量写操作的时间的减少，而读的操作效率要远远高于写的性能，因此，多出来的在循环中定位尾节点的操作的性能损耗相对而言是很小的。

3、阻塞队列BlockingQueue

BlockingQueue接口是Java.util.concurrent包下重要的数据结构，BlockingQueue提供了线程安全的队列访问方式：

当阻塞队列进行插入数据时，如果队列已满，线程将会阻塞等待直到队列非满；
从阻塞队列取数据时，如果队列已空，线程将会阻塞等待直到队列非空。

这看上去简直是为生产者/消费者模式量身定做的，阻塞队列就是生产者用来存放元素，消费者用来获取元素的同步容器。

阻塞队列BlockingQueue提供了4种不同的方法用于插入、移除以及对队列中的元素进行检查。如果请求的操作不能得到立即执行的话，每个方法的表现也不同。

抛出异常：是指当阻塞队列满时候，再往队列里插入元素，会抛出 IllegalStateException("Queue full") 异常。当队列为空时，从队列里获取元素时会抛出 NoSuchElementException 异常。
返回特殊值：插入方法会返回是否成功，成功则返回 true。移除方法，则是从队列里拿出一个元素，如果没有则返回 null
一直阻塞：当阻塞队列满时，如果生产者线程往队列里 put 元素，队列会一直阻塞生产者线程，直到拿到数据，或者响应中断退出。当队列空时，消费者线程试图从队列里 take 元素，队列也会阻塞消费者线程，直到队列可用。
超时退出：当阻塞队列满时，队列会阻塞生产者线程一段时间，如果超过一定的时间，生产者线程就会退出。

需要注意的是，如果是无界阻塞队列，队列不可能出现满的情况，所以使用put或offer方法永远不会被阻塞，offer永远返回true。

1.阻塞队列的实现原理

在前面的并发知识学习中，我们已经了解到AQS队列同步器的实现原理(具体可参考这篇文章)，以及同步组件ReentrantLock是如何通过AQS实现的(具体可参考这篇文章)，而阻塞队列则是通过重入锁ReentrantLock和其辅助类Condition实现的。

以ArrayBlockingQueue阻塞队列为例，通过其源码进行分析：

final Object[] items;
int takeIndex;
int putIndex;
int count;
final ReentrantLock lock;
private final Condition notEmpty;
private final Condition notFull;   

//构造函数
public ArrayBlockingQueue(int capacity, boolean fair) {
        //构造函数可提供初始容量和公平锁条件
        if (capacity <= 0)
            throw new IllegalArgumentException();
        //创建数组    
        this.items = new Object[capacity];
        //创建锁和阻塞条件
        lock = new ReentrantLock(fair);   
        notEmpty = lock.newCondition();
        notFull =  lock.newCondition();
    }
//添加元素的方法
public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
 //如果队列满了，那么就会阻塞当前线程到notFull条件变量的等待队列上去
            while (count == items.length)
                notFull.await();
            //如果队列不满就入队
            enqueue(e);
        } finally {
            lock.unlock();
        }
    }
 //入队的方法
 private void enqueue(E x) {
        final Object[] items = this.items;
        items[putIndex] = x;
        if (++putIndex == items.length)
            putIndex = 0;
        count++;
        notEmpty.signal();
    }
 //移除元素的方法
 public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
 //如果队列空了，那么就会阻塞当前线程到notEmpty条件变量的等待队列上去
            while (count == 0)
                notEmpty.await();
            return dequeue();
        } finally {
            lock.unlock();
        }
    }
 //出队的方法
 private E dequeue() {
        final Object[] items = this.items;
        @SuppressWarnings("unchecked")
        E x = (E) items[takeIndex];
        items[takeIndex] = null;
        if (++takeIndex == items.length)
            takeIndex = 0;
        count--;
        if (itrs != null)
            itrs.elementDequeued();
        notFull.signal();
        return x;
 }

2.Java的阻塞队列

Java利用BlockingQueue接口实现7个常用的阻塞队列类，分别如下：

ArrayBlockingQueue ：一个由数组结构组成的有界阻塞队列。
LinkedBlockingQueue ：一个由链表结构组成的有界阻塞队列。
PriorityBlockingQueue ：一个支持优先级排序的无界阻塞队列。
DelayQueue：一个使用优先级队列实现的无界阻塞队列。
SynchronousQueue：一个不存储元素的阻塞队列。
LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。
LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。

ArrayBlockingQueue

ArrayBlockingQueue是一个用数组实现的有界阻塞队列。此队列按照先进先出（FIFO）的原则对元素进行排序。

默认情况下不保证访问者公平的访问队列，所谓公平访问队列是指阻塞的所有生产者线程或消费者线程，当队列可用时，可以按照阻塞的先后顺序访问队列，即先阻塞的生产者线程，可以先往队列里插入元素，先阻塞的消费者线程，可以先从队列里获取元素。通常情况下为了保证公平性会降低吞吐量。

ArrayBlockingQueue fairQueue = new ArrayBlockingQueue(1000,true)语句可创建一个公平的阻塞队列。

其基本原理已经在上文中讨论过了，是通过重入锁ReentrantLock和其辅助类Condition实现的。

LinkedBlockingQueue

LinkedBlockingQueue 是一个用链表实现的有界阻塞队列。此队列的默认和最大长度为 Integer.MAX_VALUE。此队列按照先进先出的原则对元素进行排序。

其基本原理与和ArrayBlockingQueue是一样的，只是ArrayBlockingQueue使用数组做队列，而LinkedBlockingQueue使用链表做队列。如何选择哪种阻塞队列和如何选择数组与链表这两种数据结构的思路是一样的，对于频繁进行队列元素获取操作的场景下，首选ArrayBlockingQueue，而在需要频繁进行队列元素删除、添加的场景下首选LinkedBlockingQueue。

PriorityBlockingQueue

PriorityBlockingQueue 是一个支持优先级的无界队列。默认情况下元素采取自然顺序升序排列排列，也可以通过指定构造参数比较器comparator来指定元素的排序规则。

需要注意的同等优先级元素的顺序是无法得到保证的。

DelayQueue

DelayQueue 是一个支持延时获取元素的无界阻塞队列。队列使用 PriorityQueue 来实现。队列中的元素必须实现 Delayed 接口，在创建元素时可以指定多久才能从队列中获取当前元素。只有在延迟期满时才能从队列中提取元素。我们可以将 DelayQueue 运用在以下应用场景：

缓存系统的设计：可以用 DelayQueue 保存缓存元素的有效期，使用一个线程循环查询 DelayQueue，一旦能从 DelayQueue 中获取元素时，表示缓存有效期到了。
定时任务调度。使用 DelayQueue 保存当天将会执行的任务和执行时间，一旦从 DelayQueue 中获取到任务就开始执行，从比如 TimerQueue 就是使用 DelayQueue 实现的。

队列中的 Delayed 必须实现 compareTo 来指定元素的顺序。比如让延时时间最长的放在队列的末尾。实现代码如下：

public int compareTo(Delayed other) {
       if (other == this) // compare zero ONLY if same object
            return 0;
       if (other instanceof ScheduledFutureTask) {
                ScheduledFutureTask x = (ScheduledFutureTask)other;
                long diff = time - x.time;
                if (diff < 0)
                    return -1;
                else if (diff > 0)
                    return 1;
	            else if (sequenceNumber < x.sequenceNumber)
                    return -1;
                else
                    return 1;
       }
       long d = (getDelay(TimeUnit.NANOSECONDS) -
                other.getDelay(TimeUnit.NANOSECONDS));
       return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
}

延时队列的实现很简单，当消费者从队列里获取元素时，如果元素没有达到延时时间，就阻塞当前线程。

    public E take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                E first = q.peek();
                if (first == null)
                    available.await();
                else {
                    long delay = first.getDelay(NANOSECONDS);
                    if (delay <= 0)
                        return q.poll();
                    first = null; // don't retain ref while waiting
                    if (leader != null)
                        available.await();
                    else {
                        Thread thisThread = Thread.currentThread();
                        leader = thisThread;
                        try {
                            available.awaitNanos(delay);
                        } finally {
                            if (leader == thisThread)
                                leader = null;
                        }
                    }
                }
            }
        } finally {
            if (leader == null && q.peek() != null)
                available.signal();
            lock.unlock();
        }
    }

延时阻塞队列使用了优先阻塞队列来存储数据，数据的获取是有优先级的，这一点需要注意，在这点上，我们应该和Java的线程池的调度线程池的实现联系起来，在java的调度线程池的实现上，也使用了延时队列，而优先级队列可以保证线程池调度的任务都是根据时间优先级被调度的。take方法首先从优先队列中获取第一个元素，然后询问是否需要延时，如果不需要，则直接返回，否则延时设定的时间之后再返回。

SynchronousQueue

SynchronousQueue 是一个不存储元素的阻塞队列。每一个 put 操作必须等待一个 take 操作，否则不能继续添加元素。SynchronousQueue 可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程。队列本身并不存储任何元素，非常适合于传递性场景, 比如在一个线程中使用的数据，传递给另外一个线程使用，SynchronousQueue 的吞吐量高于 LinkedBlockingQueue 和 ArrayBlockingQueue。

LinkedTransferQueue

LinkedTransferQueue 是一个由链表结构组成的无界阻塞 TransferQueue 队列。相对于其他阻塞队列，LinkedTransferQueue 多了 tryTransfer 和 transfer 方法。

transfer方法：如果当前有消费者正在等待接收元素（消费者使用 take() 方法或带时间限制的 poll() 方法时，transfer方法可以把生产者传入的元素立刻 transfer（传输）给消费者。如果没有消费者在等待接收元素，transfer 方法会将元素存放在队列的tail节点，并等到该元素被消费者消费了才返回。transfer 方法的关键代码如下：

Node pred = tryAppend(s, haveData);
return awaitMatch(s, pred, e, (how == TIMED), nanos);

第一行代码是试图把存放当前元素的 s 节点作为 tail 节点。第二行代码是让 CPU 自旋等待消费者消费元素。因为自旋会消耗 CPU，所以自旋一定的次数后使用 Thread.yield() 方法来暂停当前正在执行的线程，并执行其他线程。

tryTransfer方法：则是用来试探下生产者传入的元素是否能直接传给消费者。如果没有消费者等待接收元素，则返回 false。和 transfer 方法的区别是 tryTransfer 方法无论消费者是否接收，方法立即返回。而 transfer 方法是必须等到消费者消费了才返回。

对于带有时间限制的 tryTransfer(E e, long timeout, TimeUnit unit) 方法，则是试图把生产者传入的元素直接传给消费者，但是如果没有消费者消费该元素则等待指定的时间再返回，如果超时还没消费元素，则返回 false，如果在超时时间内消费了元素，则返回 true。

LinkedBlockingDeque

LinkedBlockingDeque 是一个由链表结构组成的双向阻塞队列。所谓双向队列指的你可以从队列的两端插入和移出元素。双端队列因为多了一个操作队列的入口，在多线程同时入队时，也就减少了一半的竞争。

相比其他的阻塞队列，LinkedBlockingDeque 多了 addFirst，addLast，offerFirst，offerLast，peekFirst，peekLast 等方法，以 First 单词结尾的方法，表示插入，获取（peek）或移除双端队列的第一个元素。以 Last 单词结尾的方法，表示插入，获取或移除双端队列的最后一个元素。另外插入方法 add 等同于 addLast，移除方法 remove 等效于 removeFirst。但是 take 方法却等同于 takeFirst，使用时还是用带有 First 和 Last 后缀的方法更清楚。

在初始化 LinkedBlockingDeque 时可以设置容量防止其过渡膨胀。另外双向阻塞队列可以运用在“工作窃取”模式中。

CopyOnWriteArrayList/CopyOnWriteArraySet

所谓CopyOnWrite就是写入时复制，其安全性在于正确发布一个不可变的对象，那么在访问这个对象的时候就不需要再进行同步。修改的时候创建并且重新发布一个新的容器副本，从而实现可变。

写入时复制的容器不会抛出ConcurrentModificationException。但是仅仅当迭代操作远远多于修改操作的时候才应该使用写入时复制容器。

3.阻塞队列的应用

阻塞队列的最长使用的例子就是生产者消费者模式,也是各种实现生产者消费者模式方式中首选的方式。使用者不用关心什么阻塞生产，什么时候阻塞消费，代码如下：

public class BlockingQueueTest {
    //生产者
    public static class Producer implements Runnable{
        private final BlockingQueue<Integer> blockingQueue;
        private volatile boolean flag;
        private Random random;

        public Producer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
            flag=false;
            random=new Random();

        }
        public void run() {
            while(!flag){
                int info=random.nextInt(100);
                try {
                    blockingQueue.put(info);
                    System.out.println(Thread.currentThread().getName()+" produce "+info);
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }               
            }
        }
        public void shutDown(){
            flag=true;
        }
    }
    //消费者
    public static class Consumer implements Runnable{
        private final BlockingQueue<Integer> blockingQueue;
        private volatile boolean flag;
        public Consumer(BlockingQueue<Integer> blockingQueue) {
            this.blockingQueue = blockingQueue;
        }
        public void run() {
            while(!flag){
                int info;
                try {
                    info = blockingQueue.take();
                    System.out.println(Thread.currentThread().getName()+" consumer "+info);
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }               
            }
        }
        public void shutDown(){
            flag=true;
        }
    }
    public static void main(String[] args){
        BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<Integer>(10);
        Producer producer=new Producer(blockingQueue);
        Consumer consumer=new Consumer(blockingQueue);
        //创建5个生产者，5个消费者
        for(int i=0;i<10;i++){
            if(i<5){
                new Thread(producer,"producer"+i).start();
            }else{
                new Thread(consumer,"consumer"+(i-5)).start();
            }
        }

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        producer.shutDown();
        consumer.shutDown();

    }
}

参考文章：

《Java并发编程实战》

《Java并发编程的艺术》

https://juejin.im/post/5aeeae756fb9a07ab11112af

沉梦昂志1995

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java并发学习（七）并发容器

Java平台类库包含了大量的并发基础构建模块，包括线程安全的容器类以及各种用于协调多个相互协作的线程控制流的同步工具类(Synchronizer)，学习这些基础模块不仅能提高并发编程的能力，更可以从中看到Doug Lea等大师的设计思想。同步容器类同步容器类包括Vector、Hashtable以及它们的子类，还有通过Collections.synchronizedXxx的一些工...
复制链接

扫一扫