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，则迭代器将抛出此异常。