集合类同步性能分析

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
 
import com.sun.org.apache.xalan.internal.xsltc.runtime.Hashtable;
 
public class CollectionDemo {
 
	public static void main(String[] args){
		testConcurrentList();
		testConcurrentMap();
	}
 
	public static void testConcurrentList(){
		long start = System.currentTimeMillis();
		long list_time = 0;
		List list = new ArrayList();
		for(int i = 0; i < 1000000; i++){
			list.add(i);
		}
		for(int i = 0; i < list.size(); i++){
			int k = (Integer) list.get(i);
		}
		list_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long vector_time = 0;
		Vector vec = new Vector();                    
// public synchronized void insertElementAt  同步所有方法
		for(int i = 0; i < 1000000; i++){
			vec.add(i);
		}
		for(int i = 0; i < vec.size(); i++){
			int k = (Integer) vec.get(i);
		}
		vector_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long concurrentList_time = 0;
        List concurrentList = Collections.synchronizedList(new ArrayList());  
// synchronized(mutex)同步需要同步的代码块
		for(int i = 0; i < 1000000; i++){
			concurrentList.add(i);
		}
		for(int i = 0; i < concurrentList.size(); i++){
			int k = (Integer) concurrentList.get(i);
		}
		concurrentList_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long copyOnWriteArrayList_time = 0;
		CopyOnWriteArrayList  copyOnWriteArrayList = new CopyOnWriteArrayList();  
//重入锁（ReentrantLock）是一种递归无阻塞的同步机制。
		for(int i = 0; i < 1000000; i++){
			concurrentList.add(i);
		}
		for(int i = 0; i < copyOnWriteArrayList.size(); i++){
			int k = (Integer) copyOnWriteArrayList.get(i);
		}
		copyOnWriteArrayList_time = System.currentTimeMillis() - start;
 
		System.out.println("list--------------- vector--------------
Collections.synchronizedList(new ArrayList()) --------CopyOnWriteArrayList");
        System.out.println(list_time + "------------" + vector_time + "------------" 
+ concurrentList_time + "------------" + copyOnWriteArrayList_time);
	}
	public static void testConcurrentMap(){
		long start = System.currentTimeMillis();
		long map_time = 0;
		Map map = new HashMap();
		for(int i = 0; i < 1000000; i++){
			map.put("item" + i,"value" + i);
		}
		for(int i = 0; i < map.size(); i++){
			Object value = map.get("item" + i);
		}
		map_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long ht_time = 0;
		Hashtable ht = new Hashtable();
		for(int i = 0; i < 1000000; i++){
			ht.put("item" + i,"value" + i);
		}
		for(int i = 0; i < ht.size(); i++){
			Object value = ht.get("item" + i);
		}
		ht_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long concurrentMap_time = 0;
        Map concurrentMap = Collections.synchronizedMap(new HashMap());
        for(int i = 0; i < 1000000; i++){
        	concurrentMap.put("item" + i,"value" + i);
		}
		for(int i = 0; i < concurrentMap.size(); i++){
			Object value = concurrentMap.get("item" + i);
		}
		concurrentMap_time = System.currentTimeMillis() - start;
 
		start = System.currentTimeMillis();
		long copyOnWriteArrayMap_time = 0;
		ConcurrentHashMap  concurrentHashMap = new ConcurrentHashMap();
		for(int i = 0; i < 1000000; i++){
			concurrentHashMap.put("item" + i,"value" + i);
		}
		for(int i = 0; i < concurrentHashMap.size(); i++){
			Object value = concurrentHashMap.get("item" + i);
		}
		copyOnWriteArrayMap_time = System.currentTimeMillis() - start;
 
		System.out.println("map--------------- hashTable--------------
Collections.synchronizedMap(new HashMap()); --------ConcurrentHashMap");
        System.out.println(map_time + "------------" + ht_time 
+ "------------" + concurrentMap_time + "------------" 
+ copyOnWriteArrayMap_time);
	}
}

 

输出：

数据量 List vector Collections.synchronizedList CopyOnWriteArrayList
1000000 62 125 172 47
5000000 485 953 1031 625
10000000 1078 1812 2329 2343

List如果需要同步，建议使用CopyOnWriteArrayList。如果不需要同步，则用list即可，不需要用同步，因为同步消耗很大的性能。

数据量 HashMap Hashtable Collections.synchronizedMap CopyOnWriteArrayMap
1000000 1375 1094 1469 1547
5000000 6860 6281 7688 8172
100000 78 125 78 94

Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；在数据量大的时候，hashtable的性能比较好，但是hashmap的功能更加强大，而且新框架中建议使用hashmap，不要使用hashtable。

没有同步的list，用同步的三种方式实现的list性能分析：
1.用老的Vector/Hashtable类，上面2个问题都不用担心。
Vector/Hashtable所提供的所有方法都是 synchronized的。如果 迭代的过程中数据结构被修改了，迭代器可以反映最新的修改，也不会抛异常。但这种方法效率低下，不建议使用。
2.使用ArrayList/HashMap和同步包装器
可用 同步包装器使容器变成线程安全的 对某些方法用synchronized
Java代码
1. List synchArrayList = Collections.synchronizedList(new ArrayList());

2. Map synchHashMap = Collections.synchronizedMap(new HashMap())

3.用java5.0新加入的ConcurrentLinkedQueue、ConcurrentHashMap、CopyOnWriteArrayList 和 CopyOnWriteArraySet
对这些集合进行并发修改是安全的。 用重入锁（ReentrantLock）是一种递归无阻塞的同步机制实现。