并发集合

List Set Map，在遍历的过程中，不允许更新操作(增删改)，由于快速失败fail-fast机制，会抛出Concurrent Modification Exception

public class User {
    private int id;
    private String name;

    public User(int id,String name){
        this.id=id;
        this.name=name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}


import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class CollectionDemo {
    public static void main(String[] args) {
        List<User> list=new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            User user=new User(i,"User"+i);
            list.add(user);
        }
        Iterator<User> it=list.iterator();
        while(it.hasNext()){
            User user=it.next();
            if("User6".equals(user.getName()))
                list.remove(user); //这里会快速失败fail-fast机制，会抛出Concurrent Modification Exception
        }
    }
}

ConcurrentCollection分为非阻塞式集合、阻塞式集合
非阻塞式集合，如 ConcurrentLinkedDeque ：这类集合也包括添加和移除数据的方法。如果方法不能立即被执行，则返回null或抛出异常，但是调用这个方法的线程不会被阻塞。
阻塞式集合 如 LinkedBlockingDeque ：这类集合包括添加和移除数据的方法。当集合已满或为空时，被调用的添加或者移除方法就不能立即被执行，那么调用这个方法的线程将被阻塞，将线程放到阻塞队列当中，一直到该方法可以被成功执行。

DataStructure

ConcurrentHashMap:
ConcurrentLinkedQueue:
ConcurrentLinkedDeque ：

• add(E e)——将指定元素插入队列尾部
• contains(Object o)——队列是否包含指定元素，有则返回true
• isEmpty()——如果队列没有元素，返回true
• iterator()——返回队列元素上以家当顺序进行迭代的迭代器
• offer(E o)——将指定元素插入队列的尾部
• peek()——获取但不移除队列的头；如果队列为空，返回null
• poll()——获取并移除此队列的头，如果队列为空，返回null
• remove(Object o)——从队列中移除指定的元素的单个实例（如果存在）
• size()——返回队列中元素的数量
• toArray()——返回以加档顺序包含此队列所有元素的数组
• toArray(T[] a)——返回以加档顺序包含此队列所有元素的数组；返回数组的运行时类型是指定数组的运行时类型

import java.util.concurrent.ConcurrentLinkedDeque;

public class CollectionDemo01 {
    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());
    }
}

ConcurrentSkipListMap：
ConcurrentSkipListSet：
CopyOnWriteArrayList:
CopyOnWriteArraySet:
ArrayBlockingQueue:
LinkedBlockingQueue：
LinkedBlockingDeque ：阻塞式

import java.util.Date;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.TimeUnit;

public class BlockDequeDemo {
    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");

    }
}

LinkedTransferQueue：生产-消费
PriorityBlockingQueue：阻塞式，基于优先级

HashMap
数组+链表
JDK1.7中搜索一个值的时候要是遍历链表效率会比较慢会变成O(n)的复杂度
JDK1.8后链表会变成红黑树主要会把效率从O(n)变成O(logn)

CurrentHashMap