1 Java中的集合
Java中的集合分为同步的集合(线程安全)和线程不安全的集合 例如 :
ArrayList和Vector的区别：
一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的
二.数据增长:当需要增长时,Vector默认增长为原来一倍，而ArrayList默认增长为原来的1.5倍
HashMap和Hashtable的区别
一.历史原因:Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现
二.同步性:Hashtable是线程安全的，也就是说是同步的，效率低一些；而HashMap是线程序不安全的，不是同步的 效率高
三.值： HashMap允许1个key为null 多个value为null Hashtable key value都不能为null
在Java的集合容器框架中，主要有四大类别：List、Set、Queue、Map。
List、Set、Queue接口分别继承了Collection接口，Map本身是一个接口。
注意Collection和Map是一个顶层接口，而List、Set、Queue则继承了Collection接口，分别代表数组、集合和队列这三大类容器。
像ArrayList、LinkedList都是实现了List接口，HashSet实现了Set接口，而Deque（双向队列，允许在队首、队尾进行入队和出队操作）继承了Queue接口，PriorityQueue实现了Queue接口。
另外LinkedList（实际上是双向链表）实现了了Deque接口。
像ArrayList、LinkedList、HashMap这些容器都是非线程安全的。
如果有多个线程并发地访问这些容器时，就会出现问题。
因此，在编写程序时，必须要求程序员手动地在任何访问到这些容器的地方进行同步处理，这样导致在使用这些容器的时候非常地不方便。
所以，Java提供了同步容器供用户使用。
在Java中，同步容器主要包括2类：
1）Vector、Stack、HashTable
Vector实现了List接口，Vector实际上就是一个数组，和ArrayList类似，但是Vector中的方法都是synchronized方法，即进行了同步措施。
Stack也是一个同步容器，它的方法也用synchronized进行了同步，它实际上是继承于Vector类。
HashTable实现了Map接口，它和HashMap很相似，但是HashTable进行了同步处理，而HashMap没有。
关于HashMap可以参见 HashMap源码解析
2）Collections类中提供的静态工厂方法创建的类
Collections类是一个工具提供类，注意，它和Collection不同，Collection是一个顶层的接口。在Collections类中提供了大量的方法，
比如对集合或者容器进行排序、查找等操作。最重要的是，在它里面提供了几个静态工厂方法来创建同步容器类，如下图所示：
这里面的采用了装饰模式<装饰模式>的思想，以synchronizedMap(Map<K,V> m)为例：
1 public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m) {
2 return new SynchronizedMap<K,V>(m);
3 }他返回了类型为SynchronizedMap的实例，而SynchronizedMap是COllections的一个内部类，他对原来对象的方法加上了synchronized关键字：
1 private static class SynchronizedMap<K,V> implements Map<K,V>, Serializable {//继承目标对象的类型
2
3 private static final long serialVersionUID = 1978198479659022715L;
4
5 private final Map<K,V> m; // 被装饰的对象
6 final Object mutex; // 公共的锁
7
8 SynchronizedMap(Map<K,V> m) {
9 if (m==null)
10 throw new NullPointerException();
11 this.m = m;
12 mutex = this;
13 }
14
15 SynchronizedMap(Map<K,V> m, Object mutex) {
16 this.m = m;
17 this.mutex = mutex;
18 }
19
20 public int size() {
21 synchronized(mutex) {return m.size();} //使用synchronized对目标对象的方法进行增强
22 }
23 public boolean isEmpty(){
24 synchronized(mutex) {return m.isEmpty();}
25 }
26
27 public V get(Object key) {
28 synchronized(mutex) {return m.get(key);}
29 }
30
31 public V put(K key, V value) {
32 synchronized(mutex) {return m.put(key, value);}
33 }
34 //... ...
35 }
二 并发容器的问题
从同步容器的具体实现源码可知，同步容器中的方法采用了synchronized进行了同步，那么很显然，这必然会影响到执行性能，
另外，同步容器就一定是真正地完全线程安全吗？
1 传统的非同步容器和同步容器的性能差异，我们以ArrayList和Vector为例：
1 public class Test {
2 public static void main(String[] args) throws InterruptedException {
3 ArrayList<Integer> list = new ArrayList<Integer>();
4 Vector<Integer> vector = new Vector<Integer>();
5 long start = System.currentTimeMillis();
6 for(int i=0;i<100000;i++)
7 list.add(i);
8 long end = System.currentTimeMillis();
9 System.out.println("ArrayList进行100000次插入操作耗时："+(end-start)+"ms");
10 start = System.currentTimeMillis();
11 for(int i=0;i<100000;i++)
12 vector.add(i);
13 end = System.currentTimeMillis();
14 System.out.println("Vector进行100000次插入操作耗时："+(end-start)+"ms");
15 }
16 }
进行同样多的插入操作，Vector的耗时是ArrayList的两倍。 这只是其中的一方面性能问题上的反映。
另外，由于Vector中的add方法和get方法都进行了同步，因此，在有多个线程进行访问时，如果多个线程都只是进行读取操作，
那么每个时刻就只能有一个线程进行读取，其他线程便只能等待，这些线程必须竞争同一把锁。
因此为了解决同步容器的性能问题，在Java 1.5中提供了并发容器，位于java.util.concurrent目录下
2.同步容器真的是安全的吗？
也有有人认为Vector中的方法都进行了同步处理，那么一定就是线程安全的，事实上这可不一定。看下面这段代码：
1 public class Test {
2 static Vector<Integer> vector = new Vector<Integer>();
3 public static void main(String[] args) throws InterruptedException {
4 while(true) {
5 for(int i=0;i<10;i++)
6 vector.add(i);
7 Thread thread1 = new Thread(){
8 public void run() {
9 for(int i=0;i<vector.size();i++)
10 vector.remove(i);
11 };
12 };
13 Thread thread2 = new Thread(){
14 public void run() {
15 for(int i=0;i<vector.size();i++)
16 vector.get(i);
17 };
18 };
19 thread1.start();
20 thread2.start();
21 while(Thread.activeCount()>10) {
22
23 }
24 }
25 }
26 }
正如大家所看到的，这段代码报错了：数组下标越界。
Vector是线程安全的，为什么还会报这个错？很简单，对于Vector，虽然能保证每一个时刻只能有一个线程访问它，但是不排除这种可能：
当某个线程在某个时刻执行这句时：
for(int i=0;i<vector.size();i++)
vector.get(i);
假若此时vector的size方法返回的是10，i的值为9
然后另外一个线程执行了这句：
for(int i=0;i<vector.size();i++)
vector.remove(i);
将下标为9的元素删除了。
那么通过get方法访问下标为9的元素肯定就会出问题了。
因此为了保证线程安全，必须在方法调用端做额外的同步措施，如下面所示：
1 public class Test {
2 static Vector<Integer> vector = new Vector<Integer>();
3 public static void main(String[] args) throws InterruptedException {
4 while(true) {
5 for(int i=0;i<10;i++)
6 vector.add(i);
7 Thread thread1 = new Thread(){
8 public void run() {
9 synchronized (Test.class) { //进行额外的同步
10 for(int i=0;i<vector.size();i++)
11 vector.remove(i);
12 }
13 };
14 };
15 Thread thread2 = new Thread(){
16 public void run() {
17 synchronized (Test.class) {
18 for(int i=0;i<vector.size();i++)
19 vector.get(i);
20 }
21 };
22 };
23 thread1.start();
24 thread2.start();
25 while(Thread.activeCount()>10) {
26
27 }
28 }
29 }
30 }
3. ConcurrentModificationException异常
在对Vector等容器并发地进行迭代修改时，会报ConcurrentModificationException异常，关于这个异常将会在后续文章中讲述。
但是在并发容器中不会出现这个问题。
注意：
当使用Iterator对集合元素进行迭代时，Iterator并不是把集合元素本身传给迭代变量，而是把集合元素的值传给了迭代变量。
所以迭代过程中修改了值 并不会影响到集合里的元素
当使用Iterator来访问Collection集合元素时，只有通过Iterator的remove方法删除（it.remove();）上一次next方法返回的集合元素。
如果通过集合方法删除 会引发java.util.ConcurrentModificationExcption异常。
----在使用迭代器遍历时不能够通过集合直接修改元素 而应该借助迭代器提供的方法
ConcurrentModificationException：
例如，某个线程在 Collection 上进行迭代时，通常不允许另一个线性修改该 Collection。
通常在这些情况下，迭代的结果是不确定的。如果检测到这种行为，一些迭代器实现（包括 JRE 提供的所有通用 collection 实现）可能选择抛出此异常。
执行该操作的迭代器称为快速失败 迭代器，因为迭代器很快就完全失败，而不会冒着在将来某个时间任意发生不确定行为的风险。
注意，此异常不会始终指出对象已经由不同 线程并发修改。如果单线程发出违反对象协定的方法调用序列，则该对象可能抛出此异常。
例如，如果线程使用快速失败迭代器在 collection 上迭代时直接修改该 collection，则迭代器将抛出此异常。
不积跬步无以至千里
