Java中线程安全的集合

Java中线程安全的集合

---

引言：

         本文主要分享了Collection体系集合下除了Vector以外的线程安全集合，包括：Collection中的安全工具方法、子类CopyOnWriteArrayList、CopyOnWriteArraySet、ConcurrentHashMap、Queue接口、ConcurrentLinkedQueue、BlockingQueue以及阻塞队列；

相关文章：

• Java多线程超详细笔记：分享了多线程的实现方式、7种状态、线程安全的两种解决方案以及死锁、生产者消费者问题；
• Java高级多线程：分享了多线程中的线程池概念以及获取线程池的方法、Callable接口、Future接口、线程的同步以及异步、ReentrantLock（重入锁）、ReentrantRaedWriteLock（读写锁）

Collection体系集合下除了Vector以外的线程安全集合；（线程安全且没有影响效率）

Vector：对方法多加了把锁，性能低；

1. Collection中的工具方法

Collection工具类中提供了多个可以获得线程安全集合的方法；

• public static < T >Collection< T > synchronizedCollection(Collection< T > c)
• public static < T >List< T > synchronizedList(List< T > list)
• public static < T >Set< T > synchronizedSet(Collection< T > set)
• public static < K,V >Map< K,V > synchronizedMap(Collection< K,V > map)
• public static < T >SortedSet< T > synchronizedSortedSet(Collection< T > s)
• public static < K,V >SortedMap< K,V > synchronizedSortedMap(Collection< K,V > m)

• JDK1.2提供，接口统一、维护性高，但性能没有提升，均以synchonized实现;

public class TestCollectionsForSyn {
	public static void main(String[] args) {
		List<String> list = new ArrayList<String>();
		
		List<String> safeList =  Collections.synchronizedList(list);//Collections$SynchronizedList
		//和普通集合应用无差别
		safeList.add("A");//SynchronizedList里的add方法。该方法有锁
		safeList.add("B");
		safeList.add("C");
		safeList.remove(1);
		safeList.get(1);
		
		Set<String> sets = new HashSet<String>();
		Set<String> newSet = Collections.synchronizedSet(sets);
		newSet.add("A");
		newSet.add("B");
		newSet.add("C");
		
		for(String s : newSet) {
			System.out.println(s);
		}
	}
}

• 只是加入了Synchronized锁，使得集合安全

2. CopyOnWriteArrayList

• ArrayList的一个线程安全的变体，与ArrayList的使用方式一样；

• 写有锁，读无锁，读写之间不阻塞，优于读写锁；

• 写入时，先copy一个容器副本、再添加新元素，最后替换引用；

public class TestCopyOnWriteArrayList {
	public static void main(String[] args) {
		CopyOnWriteArrayList<String> alist = new CopyOnWriteArrayList<String>();
		//写操作有锁
		alist.add("A");//将底层数组做一次复制，写的是新数组，完成赋值后将新替换为旧
		alist.add("B");//每调用一次，底层方法扩容一次
		//读操作无锁
		System.out.println(alist.get(1));//读是写操作完成之前的旧数组写完后才能读到值
	}
}

3. CopyOnWriteArraySet

• 线程安全的Set，底层使用CopyOnWriteList实现；

• 唯一不同在于使用addIfAbsent()添加元素，会遍历数组；

• 如果存在元素，则不添加；

public class TestCopyOnWriteArraySet {
	public static void main(String[] args) {	
		//无序、无下标、不允许重复
		CopyOnWriteArraySet<String> aset = new CopyOnWriteArraySet<String>();
		//写操作  表面使用的是add方法，底层实际是用的CopyOnWriteArrayList的 addIfAbsent()来判断要插入的新值是否存在
		aset.add("A"); 
		aset.add("B");
		aset.add("C");
		
		for(String s : aset) {
			System.out.println(s);
		}
	}
}

4. ConcurrentHashMap

• 初始容量默认为16段（Segment），使用分段锁设计，用法与HashMap一样；

• 不对整个Map加锁，而是为每个Segment加锁；

• 当多个对象存入同一个Segment时，才需要互斥；

• 最理想状态为16个对象分别存入16个Segment，并行数量16；

public class TestConcurrentHashMap {
	public static void main(String[] args) {
		HashMap<String,String> maps = new HashMap<String,String>();
		ConcurrentHashMap<String, String> ch = new ConcurrentHashMap<String, String>();
		
		ch.put("A","卡卡");
		ch.keySet();
	}
}

• JDK1.7：分段锁设计Segment
• JDK1.8：CAS交换算法和同步锁，同步锁锁的是表头对象，拿到锁的对象要先做节点遍历。查看有没有相同的key，相同覆盖，不同，则挂在最后一个节点的next上；

5. Queue接口（队列）

Collection的子接口，表示队列FIFO(First In First Out)

常用方法：

• 抛出异常：

  boolean add(E e)：顺序添加一个元素（达到上限后，在添加则会抛出异常）

  E remove()：获得第一个元素并移除（如果队列没有元素时，抛出异常）

  E element()：获得第一个元素但是不移除（如果队列没有元素时，抛出异常）

• 返回特殊值（推）：

  boolean offer(E e)：顺序添加一个元素（达到上限后，在添加则会返回false）

  E poll()：获得第一个元素并移除（如果队列没有元素时，返回null）

  E keep()：获得第一个元素但是不移除（如果队列没有元素时，返回null）

5.1 ConcurrentLinkedQueue

线程安全、可高效的读写的队列，高并发下性能最好的队列

无锁、CAS比较算法，修改的方法包括三个核心参数

• V：要更新的变量；
• E：预期值；
• N：新值

当V==E时，V=N；否则表示已经被更新过，取消当前操作；

public class TestQueue {
	public static void main(String[] args) {
		//线程安全
		Queue<String> q = new ConcurrentLinkedQueue<String>();
	
		q.offer("A");//插入
		q.offer("B");
		q.offer("C");
		
		q.poll();//删除表头
		System.out.println(q.peek());//获得表头
		
        System.out.println(link.peek());//队列中的第一个元素
	}
}

5.2 BlockingQueue接口

Queue的子接口，阻塞的队列，增加了两个线程状态为无限期等待的方法。

常用方法：

• void put(E e)//将指定元素插入此队列中，如果没有可用空间则等待
• E take()：获取并移除此队列头部元素，如果没有可用元素则等待
• 常用以解决生产者、消费者问题；

5.3 阻塞队列

ArrayBlockingQueue：数组结构实现，有界队列；（手工固定上限）

//手动固定队列上限
BlockingQueue<String> bq = new ArrayBlockingQueue<String>(3);

LinkedBlockingQueue：链表结构实现，无界队列；（默认上限Integer.MAX_VALUE）

//无界队列  最大有 Integer.MAX_VALUE
BlockingQueue<String> lbq = new LinkedBlockingQueue<String>();