집합 류 동기 화 성능 분석

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 50000000 485 953 1031 625 10000000 1078 1812 2329 2343
List 동기 화가 필요 하 다 면 CopyOnWriteArrayList 를 사용 하 는 것 을 권장 합 니 다.동기 화가 필요 하지 않 으 면 list 를 사용 하면 되 고 동기 화 를 사용 하지 않 아 도 됩 니 다. 동기 화 는 많은 성능 을 소모 하기 때 문 입 니 다.
데 이 터 량 HashMap Hashtable Collections. synchronizedMap CopyOnWriteArrayMap 1000000 1375 1094 1469 1547 50000000 6860 6281 7688 8172 100000 78 125 78 94
Hashtable 은 Dictionary 의 하위 클래스 이 고 HashMap 은 Map 인터페이스의 실현 클래스 입 니 다.데이터 양 이 많 을 때 hashtable 의 성능 이 좋 지만 hashmap 의 기능 이 더욱 강하 고 새로운 프레임 워 크 에 서 는 hashmap 를 사용 하 는 것 을 권장 합 니 다. hashtable 을 사용 하지 마 십시오.
동기 화 된 list 가 없 으 면 동기 화 된 세 가지 방식 으로 이 루어 진 list 성능 분석: 1. 오래된 Vector / Hashtable 류 로 위의 두 가지 문 제 는 걱정 하지 않 아 도 됩 니 다.Vector / Hashtable 이 제공 하 는 모든 방법 은 synchronized 입 니 다.교체 과정 에서 데이터 구조 가 수정 되면 교체 기 는 최신 수정 을 반영 할 수 있 고 이상 을 버 리 지 않 는 다.그러나 이런 방법 은 효율 이 낮 아 사용 을 권장 하지 않 는 다.2. ArrayList / HashMap 과 동기 화 포장 기 를 사용 하면 동기 화 포장 기 를 사용 하여 용 기 를 스 레 드 로 안전하게 만 들 수 있 습 니 다. 어떤 방법 은 synchronized Java 코드 1. List synchArray List = Collections. synchronized List (new ArrayList) 를 사용 합 니 다.2. Map synchHashMap = Collections. synchronizedMap (new HashMap () 3. java 5.0 으로 새로 가입 한 Concurrent LinkedQueue, Concurrent HashMap, CopyOnWriteArray List 와 CopyOnWriteArray Set 로 이 집합 을 병행 수정 하 는 것 이 안전 합 니 다.재 접속 잠 금 (ReentrantLock) 은 재 귀적 으로 막 히 지 않 는 동기 화 메커니즘 으로 이 루어 진다.