Java没有源代码的同步集合~

存档~~~~

Synchronized，volatile，lock

锁定->[就绪队列，阻塞队列]

第一个是jvm等级达到。

与volatile所不同的是，后者不能从工作存储器写回到主存储器。

所以后者经常使用于类变量的同步

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

引用下：/article/4036239.html

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树预习下就非常easy学~
* 对于红黑树记住一句话吧~~~~~
* ！！！！一颗跟和叶子为黑色。而且跟叶路径中不存在连续的红色，随意节点到叶子节点的全部路径有同样数量的黑色节点的自二叉平衡树
*/
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");

}
}