Java集合类源码同步否~

存档~~~~

Synchronized，volatile，lock

锁->[就绪队列，堵塞队列]

第一个是jvm层次实现的。与volatile不同的是，后者不能从工作内存写回到主存。所以后者常用于类变量的同步

lock来说，在竞争资源激烈的情况下，效率最高。

引用下：http://zzhonghe.iteye.com/blog/826162

synchronized：
在资源竞争不是很激烈的情况下，偶尔会有同步的情形下，synchronized是很合适的。原因在于，编译程序通常会尽可能的进行优化synchronize，另外可读性非常好，不管用没用过5.0多线程包的程序员都能理解。

ReentrantLock:
ReentrantLock提供了多样化的同步，比如有时间限制的同步，可以被Interrupt的同步（synchronized的同步是不能Interrupt的）等。在资源竞争不激烈的情形下，性能稍微比synchronized差点点。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。

Atomic:
和上面的类似，不激烈情况下，性能比synchronized略逊，而激烈的时候，也能维持常态。激烈的时候，Atomic的性能会优于ReentrantLock一倍左右。但是其有一个缺点，就是只能同步一个值，一段代码中只能出现一个Atomic的变量，多于一个同步无效。因为他不能在多个Atomic之间同步。

附一下，快速查看源码吧

package com.lean;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.TreeSet;
import java.util.Vector;

public class JavaSouse {
	public static void main(String[] args) {

/*
 * Collection->List,Set
 * Map
 */
		
//-----------Map接口-----------------
		/*
		 * !!!!继承Dictionary，实现Map接口了
		 * 负载因子0.75  容器长度11
		 * 阏值=容器量*负载因子
		 * 方法同步
		 * 超出阏值，扩增2倍newCapacity = oldCapacity * 2 + 1;
		 */
		Hashtable<String,String> ht= new Hashtable<String,String>();
		ht.put("0", "0");
		
		/*
		 * 继承AbstractMap,实现Map接口
		 * 方法不同步
		 * 2倍扩增
		 */
		HashMap<String,String>  hm=new HashMap<String,String>();
		hm.put("0", "0");
		
		/*
		 * synchronized实现同步
		 * 
		 */
		Collections.synchronizedMap(hm);
	
//---------------------Set接口	----------------基于Map接口实现的类实现的
		
		/*
		 *继承AbstractSet，实现Set
		 *方法不同步
		 * 集合内元素不同
		 * resize(2 * table.length);扩增2倍容量
		 */
		HashSet<String> hs=new HashSet<String>();
		hs.add("0");
		
		/*
		 * 
		 */
		LinkedHashSet<String > lhs=new LinkedHashSet<String>();
		lhs.add("0");
		/*
		 * 基于TreeMap实现
		 * 排序升序对象集--红黑树---2-3-4树预习下就很容易学~
		 * 对于红黑树记住一句话吧~~~~~
		 * ！！！！一颗跟和叶子为黑色，并且跟叶路径中不存在连续的红色，任意节点到叶子节点的所有路径有相同数量的黑色节点的自二叉平衡树
		 */
		TreeSet<String > ts=new TreeSet<String>();
		ts.add("0");
	
		
//---	List接口	-----------------------基于Array接口实现
		/*
		 *方法不同步
		 * object数组实现的,初始化容量10
		 * modCount记录修改的次数，数组迭代过程可以有效的判断失败并返回
		 * 扩增1.5倍
		 */
		ArrayList<String> al=new ArrayList<String>();
		al.add("0");
		
		LinkedList<String> ll=new LinkedList<String>();
		ll.add("00");
		
		/*
		 * 方法同步synchronized
		 * 默认10，扩增2倍：
		 * int newCapacity = (capacityIncrement > 0) ?(oldCapacity + capacityIncrement) : (oldCapacity * 2);
		 * 
		 */
		Vector<String> vt=new Vector<String>();
		vt.add("1");
		
		
	}
}