java并发集合

非阻塞式集合（Non-Blocking Collection） 

这类集合也包括添加和移除数据的方法。如果方法不能立即被执行，则返回null或抛出异常，但是调用这个方法的线程不会被阻塞。

ConcurrentLinkedDeque

常用方法

1、add(E e)：在此deque的尾部插入指定的元素，返回值为Boolean。
2、addFirst(E e)：在此deque前面插入指定的元素。
3、addLast(E e)：在此deque的末尾插入指定的元素。
4、clear()：从这个deque中删除所有的元素。
5、contains(Object o)：返回 true如果这个deque包含至少一个元素 e ，返回值为Boolean。
6、descendingIterator()：以相反的顺序返回此deque中的元素的迭代器，返回值为Iterator。
7、element()：检索但不删除由此deque表示的队列的头部（换句话说，该deque的第一个元素）。
8、getFirst()：检索，但不删除，这个deque的第一个元素。
9、getLast()：检索，但不删除，这个deque的最后一个元素。
10、isEmpty()：如果此集合不包含元素，则返回 true 。
11、iterator()：以正确的顺序返回此deque中的元素的迭代器，返回值为Iterator 。
12、offer(E e)：在此deque的尾部插入指定的元素，返回值为boolean。
13、offerFirst(E e)：在此deque前面插入指定的元素，返回值为boolean。
14、offerLast(E e)：在此deque的末尾插入指定的元素，返回值为boolean。
15、peek()：检索但不删除由此deque表示的队列的头（换句话说，该deque的第一个元素），如果此deque为空，则返回 null 。
16、peekFirst()：检索但不删除此deque的第一个元素，如果此deque为空，则返回 null 。
17、peekLast()：检索但不删除此deque的最后一个元素，如果此deque为空，则返回 null 。
18、poll()：检索并删除由此deque表示的队列的头部（换句话说，该deque的第一个元素），如果此deque为空，则返回 null 。
19、pollFirst()：检索并删除此deque的第一个元素，如果此deque为空，则返回 null 。
20、pollLast()：检索并删除此deque的最后一个元素，如果此deque为空，则返回 null 。
21、pop()：从这个deque表示的堆栈中弹出一个元素。
22、push(E e)：将元素推送到由此deque代表的堆栈（换句话说，在该deque的头部），如果可以立即执行，而不违反容量限制，则抛出 IllegalStateException如果当前没有可用空间）。
23、remove()：检索并删除由此deque表示的队列的头（换句话说，该deque的第一个元素）。
24、remove(Object o)：删除第一个元素 e ，使 o.equals(e) ，如果这样一个元素存在于这个deque，返回值为boolean。
25、removeFirst()：检索并删除此deque的第一个元素。
26、removeFirstOccurrence(Object o)：删除第一个元素 e ，使 o.equals(e) ，如果这样一个元素存在于这个deque，返回值为boolean。
27、removeLast()：检索并删除此deque的最后一个元素。
28、size()：返回此deque中的元素数。

代码实例

public static void main(String[] args) throws InterruptedException{
        ConcurrentLinkedDeque<String> list=new ConcurrentLinkedDeque();
        //添加数据
        Thread[] add=new Thread[100];
        for (int i = 0; i < 100; i++) {
            add[i]=new Thread(()->{
                for (int j = 0; j < 10000; j++) {
                    list.add(Thread.currentThread().getName()+":Element "+j);
                }
            });
            add[i].start();
            add[i].join();
        }
        System.out.println("after add size:"+list.size());

        //移除数据

        Thread[] poll=new Thread[100];
        for (int i = 0; i < 100; i++) {
            poll[i]=new Thread(()->{
                for (int j = 0; j < 5000; j++) {
                    list.pollLast();
                    list.pollFirst();
                }
            });
            poll[i].start();
            poll[i].join();
        }
        System.out.println("after poll size:"+list.size());
    }

总结：

参考：https://blog.csdn.net/weixin_42146366/article/details/88012792

①、基于链接节点的无界并发deque 。 并发插入，删除和访问操作可以跨多个线程安全执行。 一个 ConcurrentLinkedDeque是许多线程将共享对公共集合的访问的适当选择。 像大多数其他并发集合实现一样，此类不允许使用null元素， ConcurrentLinkedDeque是一个双向链表 。

②、ConcurrentLinkedDeque使用了自旋+CAS的非阻塞算法来保证线程并发访问时的数据一致性。由于队列本身是一种双链表结构，所以虽然算法看起来很简单，但其实需要考虑各种并发的情况，实现复杂度较高，并且ConcurrentLinkedDeque不具备实时的数据一致性。

③、关于ConcurrentLinkedDeque还有以下需要注意的几点：

1、ConcurrentLinkedDeque的迭代器是弱一致性的，这在并发容器中是比较普遍的现象，主要是指在一个线程在遍历队列结点而另一个线程尝试对某个队列结点进行修改的话不会抛出ConcurrentModificationException，这也就造成在遍历某个尚未被修改的结点时，在next方法返回时可以看到该结点的修改，但在遍历后再对该结点修改时就看不到这种变化。
2、size方法需要遍历链表，所以在并发情况下，其结果不一定是准确的，只能供参考。

阻塞式集合（Blocking Collection）

阻塞式集合（Blocking Collection）：这类集合包括添加和移除数据的方法。当集合已满或为空时，被调用的添加或者移除方法就不能立即被执行，那么调用这个方法的线程将被阻塞，一直到该方法可以被成功执行。

LinkedBlockingDeque

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

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

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

先看一个LinkedBlockingDeque  demo

public static void main(String[] args) {
        LinkedBlockingDeque<String> list=new LinkedBlockingDeque(3);
        Thread thread=new Thread(()->{
            for (int i = 0; i < 3; i++) {
                for (int j = 0; j < 5; j++) {
                    String str=new String(i+":"+j);
                    try {
                        list.put(str.toString());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("client:"+str+(new Date()));
                }
            }
        });
        thread.start();

        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                try {
                    String str=list.take();
                    System.out.println("main:take "+str+" size:"+list.size());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        System.out.println("end");

    }

源码解读请参考：https://blog.csdn.net/qq_38293564/article/details/80592429