并发容器

不考虑多线程并发的情况下，容器类一般使用 ArrayList、HashMap 等线程不安全的类，效率更高。在并发场景下，常会用到 ConcurrentHashMap、ArrayBlockingQueue 等线程安全的容器类，虽然牺牲了一些效率，但却得到了安全。

目录

一、ConcurrentHashMap：并发版 HashMap

二、CopyOnWriteArrayList：并发版 ArrayList

三、CopyOnWriteArraySet：并发 Set

四、ConcurrentLinkedQueue：并发队列 (基于链表)

五、ConcurrentLinkedDeque：并发队列 (基于双向链表)

六、ConcurrentSkipListMap：基于跳表的并发 Map

七、ConcurrentSkipListSet：基于跳表的并发 Set

八、ArrayBlockingQueue：阻塞队列 (基于数组)

九、LinkedBlockingQueue：阻塞队列 (基于链表)

十、LinkedBlockingDeque：阻塞队列 (基于双向链表)

十一、PriorityBlockingQueue：线程安全的优先队列

十二、SynchronousQueue：读写成对的队列

十三、LinkedTransferQueue：基于链表的数据交换队列

十四、DelayQueue：延时队列：延时队列

下面我们对上面这几种并发容器进行详细的介绍。

一、ConcurrentHashMap

Map 这样的 Key Value 在软件开发中是非常经典的结构，常用于在内存中存放数据。
在多线程环境下，使用HashMap进行put操作时存在丢失数据的情况，为了避免这种bug的隐患，强烈建议使用ConcurrentHashMap代替HashMap。

哈希表

哈希表就是一种以 键-值(key-indexed) 存储数据的结构，我们只要输入待查找的值即key，即可查找到其对应的值。

哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。

链式哈希表

链式哈希表从根本上说是由一组链表构成。每个链表都可以看做是一个“桶”，我们将所有的元素通过散列的方式放到具体的不同的桶中。插入元素时，首先将其键传入一个哈希函数（该过程称为哈希键），函数通过散列的方式告知元素属于哪个“桶”，然后在相应的链表头插入元素。查找或删除元素时，用同们的方式先找到元素的“桶”，然后遍历相应的链表，直到发现我们想要的元素。因为每个“桶”都是一个链表，所以链式哈希表并不限制包含元素的个数。然而，如果表变得太大，它的性能将会降低。

应用场景

我们熟知的缓存技术（比如redis、memcached）的核心其实就是在内存中维护一张巨大的哈希表，还有大家熟知的HashMap、ConcurrentHashMap等的应用。

ConcurrentHashMap与HashMap等的区别

HashMap

我们知道HashMap是线程不安全的，在多线程环境下，使用Hashmap进行put操作会引起死循环，导致CPU利用率接近100%，所以在并发情况下不能使用HashMap。

HashTable

HashTable和HashMap的实现原理几乎一样，差别无非是：

• HashTable不允许key和value为null。
• HashTable是线程安全的。

但是HashTable线程安全的策略实现代价却太大了，简单粗暴，get/put所有相关操作都是synchronized的，这相当于给整个哈希表加了一把大锁，如下图所示：

多线程访问时候，只要有一个线程访问或操作该对象，那其他线程只能阻塞，相当于将所有的操作串行化，在竞争激烈的并发场景中性能就会非常差。

ConcurrentHashMap

ConcurrentHashMap主要就是为了应对hashmap在并发环境下不安全而诞生的，ConcurrentHashMap的设计与实现非常精巧，大量的利用了volatile，final，CAS等lock-free技术来减少锁竞争对于性能的影响。

我们都知道Map一般都是数组+链表结构（JDK1.8该为数组+红黑树）。

ConcurrentHashMap避免了对全局加锁改成了局部加锁操作，这样就极大地提高了并发环境下的操作速度，由于ConcurrentHashMap在JDK1.7和1.8中的实现非常不同，接下来我们谈谈JDK在1.7和1.8中的区别。

JDK1.7版本的ConcurrentHashMap的实现原理

在JDK1.7中ConcurrentHashMap采用了HashEntry数组+Segment分段锁的方式实现。

Segment(分段锁)

ConcurrentHashMap中的分段锁称为Segment，它即类似于HashMap的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表,同时又是一个ReentrantLock（Segment继承了ReentrantLock）。

内部结构

ConcurrentHashMap使用分段锁技术，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。如下图是ConcurrentHashMap的内部结构图：

从上面的结构我们可以了解到，ConcurrentHashMap定位一个元素的过程需要进行两次Hash操作。第一次Hash定位到Segment，第二次Hash定位到元素所在的链表的头部。

该结构的优劣势

• 坏处：这一种结构的带来的副作用是Hash的过程要比普通的HashMap要长。
• 好处：写操作的时候可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment，这样，在最理想的情况下，ConcurrentHashMap可以最高同时支持Segment数量大小的写操作（刚好这些写操作都非常平均地分布在所有的Segment上）。所以，通过这一种结构，ConcurrentHashMap的并发能力可以大大的提高。

JDK1.8版本的ConcurrentHashMap的实现原理

JDK8中ConcurrentHashMap参考了JDK8 HashMap的实现，采用了数组+链表+红黑树的实现方式来设计，如下图所示：

内部大量采用CAS操作。CAS是一种基于锁的操作，而且是乐观锁。在java中锁分为乐观锁和悲观锁。悲观锁是将资源锁住，等一个之前获得锁的线程释放锁之后，下一个线程才可以访问。而乐观锁采取了一种宽泛的态度，通过某种方式不加锁来处理资源，比如通过给记录加version来获取数据，性能较悲观锁有很大的提高。

JDK8中彻底放弃了Segment转而采用的是Node，其设计思想也不再是JDK1.7中的分段锁思想。

Node：保存key，value及key的hash值的数据结构。其中value和next都用volatile修饰，保证并发的可见性。

class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V val;
    volatile Node<K,V> next;
    //... 省略部分代码
} 

Java8 ConcurrentHashMap结构基本上和Java8的HashMap一样，不过保证线程安全性。

在JDK8中ConcurrentHashMap的结构，由于引入了红黑树，使得ConcurrentHashMap的实现非常复杂，我们都知道，红黑树是一种性能非常好的二叉查找树，其查找性能为O（logN），但是其实现过程也非常复杂，而且可读性也非常差，Doug
Lea的思维能力确实不是一般人能比的，早期完全采用链表结构时Map的查找时间复杂度为O（N），JDK8中ConcurrentHashMap在链表的长度大于某个阈值的时候会将链表转换成红黑树进一步提高其查找性能。

ConcurrentHashMap总结

其实可以看出JDK1.8版本的ConcurrentHashMap的数据结构已经接近HashMap，相对而言，ConcurrentHashMap只是增加了同步的操作来控制并发，从JDK1.7版本的ReentrantLock+Segment+HashEntry，到JDK1.8版本中synchronized+CAS+HashEntry+红黑树。

• 数据结构：取消了Segment分段锁的数据结构，取而代之的是数组+链表+红黑树的结构。
• 保证线程安全机制：JDK1.7采用segment的分段锁机制实现线程安全，其中segment继承自ReentrantLock。JDK1.8采用CAS+Synchronized保证线程安全。
• 锁的粒度：原来是对需要进行数据操作的Segment加锁，现调整为对每个数组元素加锁（Node）。
• 链表转化为红黑树:定位结点的hash算法简化会带来弊端,Hash冲突加剧,因此在链表节点数量大于8时，会将链表转化为红黑树进行存储。
• 查询时间复杂度：从原来的遍历链表O(n)，变成遍历红黑树O(logN)。

二、CopyOnWriteArrayList

Copy-On-Write简称COW，是一种用于程序设计中的优化策略。其基本思路是，从一开始大家都在共享同一个内容，当某个人想要修改这个内容的时候，才会真正把内容Copy出去形成一个新的内容然后再改，这是一种延时懒惰策略。从JDK1.5开始Java并发包里提供了两个使用CopyOnWrite机制实现的并发容器,它们是CopyOnWriteArrayList和CopyOnWriteArraySet。CopyOnWrite容器非常有用，可以在非常多的并发场景中使用到。

什么是CopyOnWrite容器

CopyOnWrite容器即写时复制的容器。通俗的理解是当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这样做的好处是我们可以对CopyOnWrite容器进行并发的读，而不需要加锁，因为当前容器不会添加任何元素。所以CopyOnWrite容器也是一种读写分离的思想，读和写不同的容器。

CopyOnWriteArrayList实现原理

在Java的并发包的并发List中只有CopyOnWriteArrayList。

CopyOnWriteArrayList是一个线程安全的ArrayList,对其进行的修改操作都是在底层的一个复制的数组（快照）上进行的，也就是使用了写时复制策略实现的。

通过查看CopyOnWriteArrayList的源码可以看出，每个CopyOnWriteArrayList对象里面有一个array数组对象用来存放具体元素，其中含有一个ReentrantLock独占锁对象用来保证同时只有一个线程对array的修改。

/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();
 
/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

CopyOnWriteArrayList会在内部创建一个大小为0的Object数组作为array的初始值，其源码如下：

public CopyOnWriteArrayList() {
    setArray(new Object[0]);
}

CopyOnWriteArrayList的有参构造函数源码如下：

//这个构造函数接收一个集合元素，它会将集合里面的元组复制到本list中
public CopyOnWriteArrayList(Collection<? extends E> c) {
	Object[] elements;
	if (c.getClass() == CopyOnWriteArrayList.class)
		elements = ((CopyOnWriteArrayList<?>)c).getArray();
	else {
		elements = c.toArray();
		// c.toArray might (incorrectly) not return Object[] (see 6260652)
		if (elements.getClass() != Object[].class)
			elements = Arrays.copyOf(elements, elements.length, Object[].class);
	}
	setArray(elements);
}

//这个构造函数用于创建一个list，其内部元素是入参toCopyIn的副本。   
public CopyOnWriteArrayList(E[] toCopyIn) {
	 setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));
}

向CopyOnWriteArrayList中添加元素

CopyOnWriteArrayList中用来添加元素的函数有add(E e), add(int index, E element), addIfAbsent(E e)和addAllAbsent(Collection<? extends E> e)等，其原理类似。

add(E w)函数的源码如下：

public boolean add(E e) {
	//获取独占锁
	final ReentrantLock lock = this.lock;
	//加锁
	lock.lock();
	try {
		//获取array
		Object[] elements = getArray();
		//获取数组长度
		int len = elements.length;
		//复制array到新数组，添加元素到新数组
		Object[] newElements = Arrays.copyOf(elements, len + 1);
		newElements[len] = e;
		//使用新数组替换添加前的数组
		setArray(newElements);
		return true;
	} finally {
		//释放独占锁
		lock.unlock();
	}
}

在多线程情况下，如果多个线程同时去调用CopyOnWriteArrayList的add(E e)方法时，只有一个线程会获取到锁，其他线程会被阻塞挂起直到独占锁被释放。

当线程获取到锁之后，就可以保证在该线程添加元素的过程中其他线程不会对array进行操作。

在执行代码Object[] newElements = Arrays.copyOf(elements, len + 1);复制array到一个新数组时，新数组的大小是原来数组大小加1，从这里我们可以知道CopyOnWriteArrayList是一个无界list。

add(E e)方法内部使用加锁机制，所以整个add过程是个原子性操作。值得注意的是，在添加元素时，首先复制了一个快照，然后在快照上进行添加，而不是在原来数组上进行的。

从CopyOnWriteArrayList中获取指定位置的元素

要从CopyOnWriteArrayList中获取指定位置的元素，我们可以使用它的 E get(int index)来获取下标为index的元素。

//该方法是通过下标来获取元素
public E get(int index) {
    return get(getArray(), index);
}

final Object[] getArray() {
    return array;
}

//该方法是首先获取array数组，然后通过下标访问指定位置的元素
@SuppressWarnings("unchecked")
private E get(Object[] a, int index) {
   return (E) a[index];
}

修改CopyOnWriteArrayList指定位置的元素

要修改CopyOnWriteArrayList指定位置的元素，可以使用CopyOnWriteArrayList中的E set(int index, E element)方法来修改list指定元素的值。

//修改指定下标为index的元素的值为element
public E set(int index, E element) {
	//获取独占锁，以保证其他线程对array数组进行修改
	final ReentrantLock lock = this.lock;
	//加锁
	lock.lock();
	try {
		//获取当前数组
		Object[] elements = getArray();
		//获取数组指定下标的旧值
		E oldValue = get(elements, index);
		//如果指定位置的元素值与新值不相等则创建新数组并复制元素
		if (oldValue != element) {
			//获取数组的长度
			int len = elements.length;
			//在新数组上修改指定位置的元素值并设置新数组到array
			Object[] newElements = Arrays.copyOf(elements, len);
			newElements[index] = element;
			setArray(newElements);
		} else {
			//如果指定位置的元素值与新值相等，为了保证volatile的内存语义，还需要重新设置array
			setArray(elements);
		}
		return oldValue;
	} finally {
		//释放锁
		lock.unlock();
	}
}

删除CopyOnWriteArrayList中的元素

要删除CopyOnWriteArrayList中的元素，可以使用E remove(int index)、boolean remove(Object o)和boolean remove(Object 0, Object[] snapshot, int index)等方法实现，它们的原理相似。

E remove(int index)方法的源码如下：

public E remove(int index) {
    //获取独占锁，以保证删除数据期间其他线程不能对array进行修改
    final ReentrantLock lock = this.lock;
    //加锁
    lock.lock();
    try {
        //获取当前数组
        Object[] elements = getArray();
        //获取数组长度
        int len = elements.length;
        //根据下标index获取数组指定元素
        E oldValue = get(elements, index);
        int numMoved = len - index - 1;
        //如果要删除的是最后一个元素
        if (numMoved == 0)
            setArray(Arrays.copyOf(elements, len - 1));
        else {
            //分两次复制删除后剩余的元素到新数组
            Object[] newElements = new Object[len - 1];
            System.arraycopy(elements, 0, newElements, 0, index);
            System.arraycopy(elements, index + 1, newElements, index,
                             numMoved);
            //使用新数组替代老数组
            setArray(newElements);
        }
        return oldValue;
    } finally {
        //释放锁
        lock.unlock();
    }
}

示例一：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
 
/**
 * @ClassName: CopyOnWriteArrayListDemo
 * @Description:  CopyOnWriteArrayList用法
 **/
public class CopyOnWriteArrayListDemo {
 
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
        //添加元素
        arrayList.add("北京");
        arrayList.add("上海");
        arrayList.add("深圳");
        arrayList.add("昆明");
        arrayList.add("天津");
        arrayList.add("银川");
        arrayList.add("兰州");
        arrayList.add("成都");
        System.out.println("arrayList = " + arrayList);
 
        //CopyOnWriteArrayList是一个无界list。
        //修改指定位置的元素
        arrayList.set(4, "广州");   //注意这里的下标index不能超出列表的长度，否则报错
        arrayList.set(5, "武汉");
        System.out.println("newArrayList = " + arrayList);
 
        //获取指定位置的元素
        String city = arrayList.get(4);
        System.out.println("city = " + city);
 
        //删除指定位置的元素
        String deleteCity = arrayList.remove(4);
        System.out.println("deleteCity = " + deleteCity);
        System.out.println("arrayList = " + arrayList);
 
        //遍历arrayList
        System.out.println("for循环遍历列表：");
        int len = arrayList.size();
        for(int i = 0; i< len; i++ ){
            System.out.println(arrayList.get(i));
        }
 
        //使用迭代器遍历
        System.out.println("迭代器遍历列表：");
        Iterator<String> itr = arrayList.iterator();
        while (itr.hasNext()){   //hasNext()方法用于判断列表中是否还有元素
            System.out.println(itr.next());   //next()方法则具体返回元素
        }
 
    }
}

示例二：

import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
 
/**
 * @ClassName: CopyOnWriteArrayListDemo1
 * @Description: CopyOnWriteArrayList用法
 * 主线程在子线程执行完毕后使用获取的迭代器遍历数组元素，从运行的结果来看，在子线程中进行的操作一个都没有生效，这就是迭代器弱一致性的体现，
 * 需要注意的是：获取迭代器的操作必须在子线程操作之前进行
 **/
public class CopyOnWriteArrayListDemo1 {
 
    private static volatile CopyOnWriteArrayList<String> arrayList = new CopyOnWriteArrayList<>();
 
    public static void main(String[] args) throws InterruptedException {
        arrayList.add("北京");
        arrayList.add("上海");
        arrayList.add("广州");
        arrayList.add("深圳");
        arrayList.add("武汉");
        arrayList.add("成都");
        arrayList.add("郑州");
        arrayList.add("长沙");
 
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                //修改list中下标为4的元素为 昆明
                arrayList.set(4, "昆明");
                //删除元素
                arrayList.remove(5);
                arrayList.remove(6);
            }
        });
 
        //保证在修改线程启动前获取迭代器
        Iterator<String> itr = arrayList.iterator();
 
        //启动线程
        thread.start();
 
        //等待子线程执行完毕
        thread.join();
 
        //迭代元素
        while (itr.hasNext()){
            System.out.println(itr.next());
        }
    }
}

CopyOnWriteArrayList的适用场景

CopyOnWrite并发容器用于读多写少的并发场景。

CopyOnWrite的缺点

CopyOnWrite容器有很多优点，但是同时也存在两个问题，即内存占用问题和数据一致性问题。所以在开发的时候需要注意一下。

• 内存占用问题。因为CopyOnWrite的写时复制机制，所以在进行写操作的时候，内存里会同时驻扎两个对象的内存，旧的对象和新写入的对象（注意:在复制的时候只是复制容器里的引用，只是在写的时候会创建新对象添加到新容器里，而旧容器的对象还在使用，所以有两份对象内存）。如果这些对象占用的内存比较大，比如说200M左右，那么再写入100M数据进去，内存就会占用300M，那么这个时候很有可能造成频繁的Yong GC和Full GC。之前我们系统中使用了一个服务由于每晚使用CopyOnWrite机制更新大对象，造成了每晚15秒的Full GC，应用响应时间也随之变长。针对内存占用问题，可以通过压缩容器中的元素的方法来减少大对象的内存消耗，比如，如果元素全是10进制的数字，可以考虑把它压缩成36进制或64进制。或者不使用CopyOnWrite容器，而使用其他的并发容器，如ConcurrentHashMap。
• 数据一致性问题。CopyOnWrite容器只能保证数据的最终一致性，不能保证数据的实时一致性。所以如果你希望写入的的数据，马上能读到，请不要使用CopyOnWrite容器。

CopyOnWriteArrayList为什么并发安全且性能比Vector好

我知道Vector是增删改查方法都加了synchronized，保证同步，但是每个方法执行的时候都要去获得锁，性能就会大大下降，而CopyOnWriteArrayList 只是在增删改上加锁，但是读不加锁，在读方面的性能就好于Vector，CopyOnWriteArrayList支持读多写少的并发情况。

三、CopyOnWriteArraySet

CopyOnWriteArraySet也是采用写时复制的思想，可以看成是线程安全的HashSet。
CopyOnWriteArraySet是通过CopyOnWriteArrayList实现的。而CopyOnWriteArrayList本质是个动态数组队列。
CopyOnWriteArraySet是一个无序集合，它不能有重复集合。
CopyOnWriteArrayList额外提供了addIfAbsent()和addAllAbsent()这两个添加元素的API，通过这些API来添加元素时，只有当元素不存在时才执行添加操作。
CopyOnWriteArraySet函数列表：

// 创建一个空 set。
CopyOnWriteArraySet()
// 创建一个包含指定 collection 所有元素的 set。
CopyOnWriteArraySet(Collection<? extends E> c)

// 如果指定元素并不存在于此 set 中，则添加它。
boolean add(E e)
// 如果此 set 中没有指定 collection 中的所有元素，则将它们都添加到此 set 中。
boolean addAll(Collection<? extends E> c)
// 移除此 set 中的所有元素。
void clear()
// 如果此 set 包含指定元素，则返回 true。
boolean contains(Object o)
// 如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean containsAll(Collection<?> c)
// 比较指定对象与此 set 的相等性。
boolean equals(Object o)
// 如果此 set 不包含任何元素，则返回 true。
boolean isEmpty()
// 返回按照元素添加顺序在此 set 中包含的元素上进行迭代的迭代器。
Iterator<E> iterator()
// 如果指定元素存在于此 set 中，则将其移除。
boolean remove(Object o)
// 移除此 set 中包含在指定 collection 中的所有元素。
boolean removeAll(Collection<?> c)
// 仅保留此 set 中那些包含在指定 collection 中的元素。
boolean retainAll(Collection<?> c)
// 返回此 set 中的元素数目。
int size()
// 返回一个包含此 set 所有元素的数组。
Object[] toArray()
// 返回一个包含此 set 所有元素的数组；返回数组的运行时类型是指定数组的类型。
<T> T[] toArray(T[] a)

四、ConcurrentLinkedQueue

一个基于链接节点的无界线程安全队列。此队列按照 FIFO（先进先出）原则对元素进行排序。队列的头部 是队列中时间最长的元素。队列的尾部 是队列中时间最短的元素。

新的元素插入到队列的尾部，队列获取操作从队列头部获得元素。当多个线程共享访问一个公共 collection 时，ConcurrentLinkedQueue 是一个恰当的选择。此队列不允许使用 null 元素。

构造方法

ConcurrentLinkedQueue() ：创建一个最初为空的 ConcurrentLinkedQueue。

ConcurrentLinkedQueue(Collection<? extends E> c) ：创建一个最初包含给定 collection 元素的 ConcurrentLinkedQueue，按照此 collection 迭代器的遍历顺序来添加元素。

offer(E e) 

将指定元素插入此队列的尾部。

ConcurrentLinkedQueue中的add() 和 offer() 完全一样，都是往队列尾部添加元素

poll() 

获取并移除此队列的头，如果此队列为空，则返回 null。

peek() 

获取但不移除此队列的头；如果此队列为空，则返回 null。

remove(Object o) 

从队列中移除指定元素的单个实例（如果存在）

remove一个已存在元素，会返回true，remove不存在元素，返回false。

size() 和 isEmpty()

size() 返回此队列中的元素数量。

如果此队列包含的元素数大于 Integer.MAX_VALUE，则返回 Integer.MAX_VALUE。
需要小心的是，与大多数 collection 不同，此方法不是 一个固定时间操作。由于这些队列的异步特性，确定当前的元素数需要进行一次花费 O(n) 时间的遍历。
所以在需要判断队列是否为空时，尽量不要用 queue.size()>0，而是用 !queue.isEmpty()

contains(Object o) 

如果此队列包含指定元素，则返回 true。

toArray() 

返回以恰当顺序包含此队列所有元素的数组。

toArray(T[] a) 

返回以恰当顺序包含此队列所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

iterator() 

返回在此队列元素上以恰当顺序进行迭代的迭代器。

五、ConcurrentLinkedDeque

ConcurrentLinkedDeque 是基于链表的无限双端队列，线程安全，不允许 null 元素。

ConcurrentLinkedDeque 内部通过 CAS 来实现线程同步，一般来说，如果需要使用线程安全的双端队列，那么推荐使用该类。

由于双端队列的特性，该类同样可以当做栈来使用，所以如果需要在并发环境下使用栈，也可以使用该类。

ConcurrentLinkedDeque 作为队列（FIFO）使用时的方法：

队列方法	等效的双端队列方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

ConcurrentLinkedDeque 作为堆栈（FILO）使用时的方法：

堆栈方法	等效的双端队列方法
push(e)	addFirst(e)
pop(e)	removeFirst(e)
peek()	peekFirst()

六、ConcurrentSkipListMap

ConcurrentSkipListMap是线程安全的有序的哈希表，适用于高并发的场景。

ConcurrentSkipListMap和TreeMap，它们虽然都是有序的哈希表。但是，第一，它们的线程安全机制不同，TreeMap是非线程安全的，而ConcurrentSkipListMap是线程安全的。第二，ConcurrentSkipListMap是通过跳表实现的，而TreeMap是通过红黑树实现的。

在4线程1.6万数据的条件下，ConcurrentHashMap 存取速度是ConcurrentSkipListMap 的4倍左右。

但ConcurrentSkipListMap有几个ConcurrentHashMap 不能比拟的优点：

• ConcurrentSkipListMap 的key是有序的。
• ConcurrentSkipListMap 支持更高的并发。ConcurrentSkipListMap 的存取时间是log（N），和线程数几乎无关。也就是说在数据量一定的情况下，并发的线程越多，ConcurrentSkipListMap越能体现出他的优势。 

在非多线程的情况下，应当尽量使用TreeMap。此外对于并发性相对较低的并行程序可以使用Collections.synchronizedSortedMap将TreeMap进行包装，也可以提供较好的效率。对于高并发程序，应当使用ConcurrentSkipListMap，能够提供更高的并发度。
所以在多线程程序中，如果需要对Map的键值进行排序时，请尽量使用ConcurrentSkipListMap，可能得到更好的并发度。

注意，调用ConcurrentSkipListMap的size时，由于多个线程可以同时对映射表进行操作，所以映射表需要遍历整个链表才能返回元素个数，这个操作是个O(log(n))的操作。

方法列表

// 构造一个新的空映射，该映射按照键的自然顺序进行排序。
ConcurrentSkipListMap()
// 构造一个新的空映射，该映射按照指定的比较器进行排序。
ConcurrentSkipListMap(Comparator<? super K> comparator)
// 构造一个新映射，该映射所包含的映射关系与给定映射包含的映射关系相同，并按照键的自然顺序进行排序。
ConcurrentSkipListMap(Map<? extends K,? extends V> m)
// 构造一个新映射，该映射所包含的映射关系与指定的有序映射包含的映射关系相同，使用的顺序也相同。
ConcurrentSkipListMap(SortedMap<K,? extends V> m)
 
// 返回与大于等于给定键的最小键关联的键-值映射关系；如果不存在这样的条目，则返回 null。
Map.Entry<K,V> ceilingEntry(K key)
// 返回大于等于给定键的最小键；如果不存在这样的键，则返回 null。
K ceilingKey(K key)
// 从此映射中移除所有映射关系。
void clear()
// 返回此 ConcurrentSkipListMap 实例的浅表副本。
ConcurrentSkipListMap<K,V> clone()
// 返回对此映射中的键进行排序的比较器；如果此映射使用键的自然顺序，则返回 null。
Comparator<? super K> comparator()
// 如果此映射包含指定键的映射关系，则返回 true。
boolean containsKey(Object key)
// 如果此映射为指定值映射一个或多个键，则返回 true。
boolean containsValue(Object value)
// 返回此映射中所包含键的逆序 NavigableSet 视图。
NavigableSet<K> descendingKeySet()
// 返回此映射中所包含映射关系的逆序视图。
ConcurrentNavigableMap<K,V> descendingMap()
// 返回此映射中所包含的映射关系的 Set 视图。
Set<Map.Entry<K,V>> entrySet()
// 比较指定对象与此映射的相等性。
boolean equals(Object o)
// 返回与此映射中的最小键关联的键-值映射关系；如果该映射为空，则返回 null。
Map.Entry<K,V> firstEntry()
// 返回此映射中当前第一个（最低）键。
K firstKey()
// 返回与小于等于给定键的最大键关联的键-值映射关系；如果不存在这样的键，则返回 null。
Map.Entry<K,V> floorEntry(K key)
// 返回小于等于给定键的最大键；如果不存在这样的键，则返回 null。
K floorKey(K key)
// 返回指定键所映射到的值；如果此映射不包含该键的映射关系，则返回 null。
V get(Object key)
// 返回此映射的部分视图，其键值严格小于 toKey。
ConcurrentNavigableMap<K,V> headMap(K toKey)
// 返回此映射的部分视图，其键小于（或等于，如果 inclusive 为 true）toKey。
ConcurrentNavigableMap<K,V> headMap(K toKey, boolean inclusive)
// 返回与严格大于给定键的最小键关联的键-值映射关系；如果不存在这样的键，则返回 null。
Map.Entry<K,V> higherEntry(K key)
// 返回严格大于给定键的最小键；如果不存在这样的键，则返回 null。
K higherKey(K key)
// 如果此映射未包含键-值映射关系，则返回 true。
boolean isEmpty()
// 返回此映射中所包含键的 NavigableSet 视图。
NavigableSet<K> keySet()
// 返回与此映射中的最大键关联的键-值映射关系；如果该映射为空，则返回 null。
Map.Entry<K,V> lastEntry()
// 返回映射中当前最后一个（最高）键。
K lastKey()
// 返回与严格小于给定键的最大键关联的键-值映射关系；如果不存在这样的键，则返回 null。
Map.Entry<K,V> lowerEntry(K key)
// 返回严格小于给定键的最大键；如果不存在这样的键，则返回 null。
K lowerKey(K key)
// 返回此映射中所包含键的 NavigableSet 视图。
NavigableSet<K> navigableKeySet()
// 移除并返回与此映射中的最小键关联的键-值映射关系；如果该映射为空，则返回 null。
Map.Entry<K,V> pollFirstEntry()
// 移除并返回与此映射中的最大键关联的键-值映射关系；如果该映射为空，则返回 null。
Map.Entry<K,V> pollLastEntry()
// 将指定值与此映射中的指定键关联。
V put(K key, V value)
// 如果指定键已经不再与某个值相关联，则将它与给定值关联。
V putIfAbsent(K key, V value)
// 从此映射中移除指定键的映射关系（如果存在）。
V remove(Object key)
// 只有目前将键的条目映射到给定值时，才移除该键的条目。
boolean remove(Object key, Object value)
// 只有目前将键的条目映射到某一值时，才替换该键的条目。
V replace(K key, V value)
// 只有目前将键的条目映射到给定值时，才替换该键的条目。
boolean replace(K key, V oldValue, V newValue)
// 返回此映射中的键-值映射关系数。
int size()
// 返回此映射的部分视图，其键的范围从 fromKey 到 toKey。
ConcurrentNavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
// 返回此映射的部分视图，其键值的范围从 fromKey（包括）到 toKey（不包括）。
ConcurrentNavigableMap<K,V> subMap(K fromKey, K toKey)
// 返回此映射的部分视图，其键大于等于 fromKey。
ConcurrentNavigableMap<K,V> tailMap(K fromKey)
// 返回此映射的部分视图，其键大于（或等于，如果 inclusive 为 true）fromKey。
ConcurrentNavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
// 返回此映射中所包含值的 Collection 视图。
Collection<V> values()

示例：

import java.util.*;
import java.util.concurrent.*;

/*
 *   ConcurrentSkipListMap是“线程安全”的哈希表，而TreeMap是非线程安全的。
 *
 *   下面是“多个线程同时操作并且遍历map”的示例
 *   (01) 当map是ConcurrentSkipListMap对象时，程序能正常运行。
 *   (02) 当map是TreeMap对象时，程序会产生ConcurrentModificationException异常。
 */
public class ConcurrentSkipListMapDemo1 {

    // TODO: map是TreeMap对象时，程序会出错。
    //private static Map<String, String> map = new TreeMap<String, String>();
    private static Map<String, String> map = new ConcurrentSkipListMap<String, String>();
    public static void main(String[] args) {
    
        // 同时启动两个线程对map进行操作！
        new MyThread("a").start();
        new MyThread("b").start();
    }

    private static void printAll() {
        String key, value;
        Iterator iter = map.entrySet().iterator();
        while(iter.hasNext()) {
            Map.Entry entry = (Map.Entry)iter.next();
            key = (String)entry.getKey();
            value = (String)entry.getValue();
            System.out.print("("+key+", "+value+"), ");
        }
        System.out.println();
    }

    private static class MyThread extends Thread {
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
                int i = 0;
            while (i++ < 6) {
                // “线程名” + "序号"
                String val = Thread.currentThread().getName()+i;
                map.put(val, "0");
                // 通过“Iterator”遍历map。
                printAll();
            }
        }
    }
}

七、ConcurrentSkipListSet

ConcurrentSkipListSet是线程安全的有序的集合，适用于高并发的场景。

ConcurrentSkipListSet和TreeSet，它们虽然都是有序的集合。但是，第一，它们的线程安全机制不同，TreeSet是非线程安全的，而ConcurrentSkipListSet是线程安全的。第二，ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的，而TreeSet是通过TreeMap实现的。

ConcurrentSkipListSet数据结构

• ConcurrentSkipListSet继承于AbstractSet。因此，它本质上是一个集合。
• ConcurrentSkipListSet实现了NavigableSet接口。因此，ConcurrentSkipListSet是一个有序的集合。
• ConcurrentSkipListSet是通过ConcurrentSkipListMap实现的。它包含一个ConcurrentNavigableMap对象m，而m对象实际上是ConcurrentNavigableMap的实现类ConcurrentSkipListMap的实例。ConcurrentSkipListMap中的元素是key-value键值对；而ConcurrentSkipListSet是集合，它只用到了ConcurrentSkipListMap中的key！

ConcurrentSkipListSet函数列表

// 构造一个新的空 set，该 set 按照元素的自然顺序对其进行排序。
ConcurrentSkipListSet()
// 构造一个包含指定 collection 中元素的新 set，这个新 set 按照元素的自然顺序对其进行排序。
ConcurrentSkipListSet(Collection<? extends E> c)
// 构造一个新的空 set，该 set 按照指定的比较器对其元素进行排序。
ConcurrentSkipListSet(Comparator<? super E> comparator)
// 构造一个新 set，该 set 所包含的元素与指定的有序 set 包含的元素相同，使用的顺序也相同。
ConcurrentSkipListSet(SortedSet<E> s)

// 如果此 set 中不包含指定元素，则添加指定元素。
boolean add(E e)
// 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E ceiling(E e)
// 从此 set 中移除所有元素。
void clear()
// 返回此 ConcurrentSkipListSet 实例的浅表副本。
ConcurrentSkipListSet<E> clone()
// 返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
Comparator<? super E> comparator()
// 如果此 set 包含指定的元素，则返回 true。
boolean contains(Object o)
// 返回在此 set 的元素上以降序进行迭代的迭代器。
Iterator<E> descendingIterator()
// 返回此 set 中所包含元素的逆序视图。
NavigableSet<E> descendingSet()
// 比较指定对象与此 set 的相等性。
boolean equals(Object o)
// 返回此 set 中当前第一个（最低）元素。
E first()
// 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E floor(E e)
// 返回此 set 的部分视图，其元素严格小于 toElement。
NavigableSet<E> headSet(E toElement)
// 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
NavigableSet<E> headSet(E toElement, boolean inclusive)
// 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E higher(E e)
// 如果此 set 不包含任何元素，则返回 true。
boolean isEmpty()
// 返回在此 set 的元素上以升序进行迭代的迭代器。
Iterator<E> iterator()
// 返回此 set 中当前最后一个（最高）元素。
E last()
// 返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E lower(E e)
// 获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E pollFirst()
// 获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
E pollLast()
// 如果此 set 中存在指定的元素，则将其移除。
boolean remove(Object o)
// 从此 set 中移除包含在指定 collection 中的所有元素。
boolean removeAll(Collection<?> c)
// 返回此 set 中的元素数目。
int size()
// 返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
// 返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
NavigableSet<E> subSet(E fromElement, E toElement)
// 返回此 set 的部分视图，其元素大于等于 fromElement。
NavigableSet<E> tailSet(E fromElement)
// 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
NavigableSet<E> tailSet(E fromElement, boolean inclusive)

ConcurrentSkipListSet示例

import java.util.*;
import java.util.concurrent.*;

/*
 *   ConcurrentSkipListSet是“线程安全”的集合，而TreeSet是非线程安全的。
 *
 *   下面是“多个线程同时操作并且遍历集合set”的示例
 *   (01) 当set是ConcurrentSkipListSet对象时，程序能正常运行。
 *   (02) 当set是TreeSet对象时，程序会产生ConcurrentModificationException异常。
 *
 */
public class ConcurrentSkipListSetDemo1 {

    // TODO: set是TreeSet对象时，程序会出错。
    //private static Set<String> set = new TreeSet<String>();
    private static Set<String> set = new ConcurrentSkipListSet<String>();
    public static void main(String[] args) {

        // 同时启动两个线程对set进行操作！
        new MyThread("a").start();
        new MyThread("b").start();
    }

    private static void printAll() {
        String value = null;
        Iterator iter = set.iterator();
        while(iter.hasNext()) {
            value = (String)iter.next();
            System.out.print(value+", ");
        }
        System.out.println();
    }

    private static class MyThread extends Thread {
        MyThread(String name) {
            super(name);
        }
        @Override
        public void run() {
                int i = 0;
            while (i++ < 10) {
                // “线程名” + "序号"
                String val = Thread.currentThread().getName() + (i%6);
                set.add(val);
                // 通过“Iterator”遍历set。
                printAll();
            }
        }
    }
}

八、ArrayBlockingQueue

ArrayBlockingQueue是一个阻塞式的队列，继承自AbstractBlockingQueue,间接的实现了Queue接口和Collection接口。底层以数组的形式保存数据(实际上可看作一个循环数组)。常用的操作包括 add，offer，put，remove，poll，take，peek。

ArrayBlockingQueue 是一个有界队列，有界也就意味着，它不能够存储无限多数量的对象。所以在创建 ArrayBlockingQueue 时，必须要给它指定一个队列的大小。

ArrayBlockingQueue 中的几个重要的方法：

• add(E e)：把 e 加到 BlockingQueue 里，即如果 BlockingQueue 可以容纳，则返回 true，否则报异常。
• offer(E e)：表示如果可能的话，将 e 加到 BlockingQueue 里，即如果 BlockingQueue 可以容纳，则返回 true，否则返回 false。 
• put(E e)：把 e 加到 BlockingQueue 里，如果 BlockQueue 没有空间，则调用此方法的线程被阻断直到 BlockingQueue 里面有空间再继续。
• poll(time)：取走 BlockingQueue 里排在首位的对象，若不能立即取出，则可以等 time 参数规定的时间,取不到时返回 null。
• take()：取走 BlockingQueue 里排在首位的对象，若 BlockingQueue 为空，阻断进入等待状态直到 Blocking 有新的对象被加入为止 。
• remainingCapacity()：剩余可用的大小。等于初始容量减去当前的 size。

ArrayBlockingQueue 使用场景：

• 先进先出队列（队列头的是最先进队的元素；队列尾的是最后进队的元素）
• 有界队列（即初始化时指定的容量，就是队列最大的容量，不会出现扩容，容量满，则阻塞进队操作；容量空，则阻塞出队操作）
• 队列不支持空元素。

九、LinkedBlockingQueue

LinkedBlockingQueue是一个单向链表实现的阻塞队列，先进先出的顺序。支持多线程并发操作。

相比于数组实现的ArrayBlockingQueue的有界，LinkedBlockingQueue可认为是无界队列。多用于任务队列。

LinkedBlockingQueue继承AbstractQueue，实现了BlockingQueue，Serializable接口。内部使用单向链表存储数据，不接受null。

默认初始化容量是Integer最大值。

插入和取出使用不同的锁，putLock插入锁，takeLock取出锁，添加和删除数据的时候可以并行。多CPU情况下可以同一时刻既消费又生产。

放入数据：

• offer(anObject):表示如果可能的话,将anObject加到BlockingQueue里,即如果BlockingQueue可以容纳,则返回true,否则返回false.（本方法不阻塞当前执行方法的线程）。
• offer(E o, long timeout, TimeUnit unit),可以设定等待的时间，如果在指定的时间内，还不能往队列中加入BlockingQueue，则返回失败。
• put(anObject):把anObject加到BlockingQueue里,如果BlockQueue没有空间,则调用此方法的线程被阻断直到BlockingQueue里面有空间再继续.

获取数据：

• poll(time):取走BlockingQueue里排在首位的对象,若不能立即取出,则可以等time参数规定的时间，取不到时返回null。
• poll(long timeout, TimeUnit unit)：从BlockingQueue取出一个队首的对象，如果在指定时间内，队列一旦有数据可取，则立即返回队列中的数据。否则知道时间超时还没有数据可取，返回失败。
• take():取走BlockingQueue里排在首位的对象,若BlockingQueue为空,阻断进入等待状态直到BlockingQueue有新的数据被加入
• drainTo():一次性从BlockingQueue获取所有可用的数据对象（还可以指定获取数据的个数），通过该方法，可以提升获取数据效率；不需要多次分批加锁或释放锁。

十、LinkedBlockingDeque

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

相比于其他阻塞队列，LinkedBlockingDeque多了addFirst、addLast、peekFirst、peekLast等方法，以first结尾的方法，表示插入、获取获移除双端队列的第一个元素。以last结尾的方法，表示插入、获取获移除双端队列的最后一个元素。

LinkedBlockingDeque是可选容量的，在初始化时可以设置容量防止其过度膨胀，如果不设置，默认容量大小为Integer.MAX_VALUE。

LinkedBlockingDeque类有三个构造方法：

public LinkedBlockingDeque()
public LinkedBlockingDeque(int capacity)
public LinkedBlockingDeque(Collection<? extends E> c)

主要方法：

• takeFirst() 和 takeLast()：分别返回类表中第一个和最后一个元素，返回的元素会从类表中移除。如果列表为空，调用的方法的线程将会被阻塞直达列表中有可用元素。
• getFirst() 和 getLast()：分别返回类表中第一个和最后一个元素，返回的元素不会从列表中移除。如果列表为空，则抛出NoSuckElementException异常。
• peek()、peekFirst() 和 peekLast()：分别返回列表中第一个元素和最后一个元素，返回元素不会被移除。如果列表为空返回null。
• poll()、pollFirst() 和 pollLast()：分别返回类表中第一个和最后一个元素，返回的元素会从列表中移除。如果列表为空，返回null。

十一、PriorityBlockingQueue

PriorityBlockingQueue是一个无界队列，它没有限制，在内存允许的情况下可以无限添加元素；它又是具有优先级的队列，是通过构造函数传入的对象来判断，传入的对象必须实现comparable接口。

需要注意，PriorityBlockingQueue中允许插入null对象。

我们可以从PriorityBlockingQueue获得一个迭代器Iterator，但这个迭代器并不保证按照优先级顺序进行迭代。

下面我们举个例子来说明一下，首先我们定义一个对象类型，这个对象需要实现Comparable接口：

public class PriorityElement implements Comparable<PriorityElement> {

	private int priority;//定义优先级
	PriorityElement(int priority) {
		//初始化优先级
		this.priority = priority;
	}
	
	@Override
	public int compareTo(PriorityElement o) {
		//按照优先级大小进行排序
		return priority >= o.getPriority() ? 1 : -1;
	}
	
	public int getPriority() {
		return priority;
	}
	
	public void setPriority(int priority) {
		this.priority = priority;
	}
	
	@Override
	public String toString() {
		return "PriorityElement [priority=" + priority + "]";
	}
}

然后我们把这些元素随机设置优先级放入队列中：

public class PriorityBlockingQueueExample {
	public static void main(String[] args) throws InterruptedException {
		PriorityBlockingQueue<PriorityElement> queue = new PriorityBlockingQueue<>();
		for (int i = 0; i < 5; i++) {
			Random random=new Random();
			PriorityElement ele = new PriorityElement(random.nextInt(10));
			queue.put(ele);
		}
		while(!queue.isEmpty()){
			System.out.println(queue.take());
		}
	}
}

十二、SynchronousQueue

SynchronousQueue队列内部仅允许容纳一个元素。当一个线程插入一个元素后会被阻塞，除非这个元素被另一个线程消费。

十三、LinkedTransferQueue

LinkedTransferQueue是在JDK1.7时，J.U.C包新增的一种比较特殊的阻塞队列，它除了具备阻塞队列的常用功能外，还有一个比较特殊的transfer方法。

我们知道，在普通阻塞队列中，当队列为空时，消费者线程（调用take或poll方法的线程）一般会阻塞等待生产者线程往队列中存入元素。而LinkedTransferQueue的transfer方法则比较特殊：

• 当有消费者线程阻塞等待时，调用transfer方法的生产者线程不会将元素存入队列，而是直接将元素传递给消费者；
• 如果调用transfer方法的生产者线程发现没有正在等待的消费者线程，则会将元素入队，然后会阻塞等待，直到有一个消费者线程来获取该元素。

TransferQueue接口

LinkedTransferQueue实现了一个名为TransferQueue的接口，TransferQueue也是JDK1.7时J.U.C包新增的接口，正是该接口提供了上述的transfer方法：

除了transfer方法外，TransferQueue还提供了两个变种方法：tryTransfer(E e)、tryTransfer(E e, long timeout, TimeUnit unit)。

tryTransfer(E e)

当生产者线程调用tryTransfer方法时，如果没有消费者等待接收元素，则会立即返回false。该方法和transfer方法的区别就是tryTransfer方法无论消费者是否接收，方法立即返回，而transfer方法必须等到消费者消费后才返回。

tryTransfer(E e, long timeout, TimeUnit unit)

tryTransfer（E e，long timeout，TimeUnit unit）方法则是加上了限时等待功能，如果没有消费者消费该元素，则等待指定的时间再返回；如果超时还没消费元素，则返回false，如果在超时时间内消费了元素，则返回true。

十四、DelayQueue

DelayQueue阻塞的是其内部元素，DelayQueue中的元素必须实现 java.util.concurrent.Delayed接口，这个接口的定义非常简单：

public interface Delayed extends Comparable<Delayed> {
    long getDelay(TimeUnit unit);
}

getDelay()方法的返回值就是队列元素被释放前的保持时间，如果返回0或者一个负值，就意味着该元素已经到期需要被释放，此时DelayedQueue会通过其take()方法释放此对象。

从上面Delayed 接口定义可以看到，它还继承了Comparable接口，这是因为DelayedQueue中的元素需要进行排序，一般情况，我们都是按元素过期时间的优先级进行排序。

例1：为一个对象指定过期时间

首先，我们先定义一个元素，这个元素要实现Delayed接口

public class DelayedElement implements Delayed {
	private long expired;
	private long delay;
	private String name;
	
	DelayedElement(String elementName, long delay) {
		this. name = elementName;
		this. delay= delay;
		expired = ( delay + System. currentTimeMillis());
	}
	
	@Override
	public int compareTo(Delayed o) {
		DelayedElement cached=(DelayedElement) o;
		return cached.getExpired()> expired?1:-1;
	}
	
	@Override
	public long getDelay(TimeUnit unit) {
		return ( expired - System. currentTimeMillis());
	}
	
	@Override
	public String toString() {
		return "DelayedElement [delay=" + delay + ", name=" + name + "]";
	}
	
	public long getExpired() {
		return expired;
	}

}

设置这个元素的过期时间为3s

public class DelayQueueExample {
	public static void main(String[] args) throws InterruptedException {
		DelayQueue<DelayedElement> queue= new DelayQueue<>();
		DelayedElement ele= new DelayedElement( "cache 3 seconds",3000);
		queue.put( ele);
		System. out.println( queue.take());
	}
}

运行这个main函数，我们可以发现，我们需要等待3s之后才会打印这个对象。

其实DelayQueue应用场景很多，比如定时关闭连接、缓存对象，超时处理等各种场景，下面我们就拿学生考试为例让大家更深入的理解DelayQueue的使用。

例2：把所有考试的学生看做是一个DelayQueue，谁先做完题目释放谁

首先，我们构造一个学生对象

public class Student implements Runnable,Delayed{
	private String name; //姓名
	private long costTime;//做试题的时间
	private long finishedTime;//完成时间
	
	public Student(String name, long costTime) {
		this. name = name;
		this. costTime= costTime;
		finishedTime = costTime + System. currentTimeMillis();
	}
	
	@Override
	public void run() {
		System. out.println( name + " 交卷,用时" + costTime /1000);
	}
	
	@Override
	public long getDelay(TimeUnit unit) {
		return ( finishedTime - System. currentTimeMillis());
	}
	
	@Override
	public int compareTo(Delayed o) {
		Student other = (Student) o;
		return costTime >= other. costTime?1:-1;
	}
}

然后在构造一个教师对象对学生进行考试

public class Teacher {
	static final int STUDENT_SIZE = 30;
	public static void main(String[] args) throws InterruptedException {
		Random r = new Random();
		//把所有学生看做一个延迟队列
		DelayQueue<Student> students = new DelayQueue<Student>();
		//构造一个线程池用来让学生们“做作业”
		ExecutorService exec = Executors.newFixedThreadPool(STUDENT_SIZE);
		for ( int i = 0; i < STUDENT_SIZE; i++) {
			//初始化学生的姓名和做题时间
			students.put( new Student( "学生" + (i + 1), 3000 + r.nextInt(10000)));
		}
		//开始做题
		while(! students.isEmpty()){
			exec.execute( students.take());
		}
		exec.shutdown();
	}
}

通过运行结果我们可以发现，每个学生在指定开始时间到达之后就会“交卷”（取决于getDelay()方法），并且是先做完的先交卷（取决于compareTo()方法）。

通过查看其源码可以看到，DelayQueue内部实现用的是PriorityQueue和一个Lock：