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