同步容器讲解

为了方便编写出线程安全的程序，Java里面提供了一些线程安全类和并发工具，比如：同步容器、并发容器、阻塞队列、Synchronizer（比如CountDownLatch）。今天我们就来讨论下同步容器。

1、为什么会出现同步容器？

在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提供了同步容器供用户使用。

2、Java中的同步容器类

在Java中，同步容器主要包括2类：

1）Vector、Stack、HashTable

2）Collections类中提供的静态工厂方法创建的类

Vector实现了List接口，Vector实际上就是一个数组，和ArrayList类似，但是Vector中的方法都是synchronized方法，即进行了同步措施。

Stack也是一个同步容器，它的方法也用synchronized进行了同步，它实际上是继承于Vector类。

HashTable实现了Map接口，它和HashMap很相似，但是HashTable进行了同步处理，而HashMap没有。

Collections类是一个工具提供类，注意，它和Collection不同，Collection是一个顶层的接口。在Collections类中提供了大量的方法，比如对集合或者容器进行排序、查找等操作。最重要的是，在它里面提供了几个静态工厂方法来创建同步容器类，如下图所示：

3、同步容器的缺陷

从同步容器的具体实现源码可知，同步容器中的方法采用了synchronized进行了同步，那么很显然，这必然会影响到执行性能，另外，同步容器就一定是真正地完全线程安全吗？不一定，这个在下面会讲到。

我们首先来看一下传统的非同步容器和同步容器的性能差异，我们以ArrayList和Vector为例：

1）性能问题

我们先通过一个例子看一下Vector和ArrayList在获取数据时性能上的差异：

import java.util.ArrayList;
import java.util.Vector;

public class Test {
	private static final int c = 100000;
	private static final ArrayList<Integer> list = new ArrayList<Integer>();
    private static final Vector<Integer> vector = new Vector<Integer>();
 
    static {
    	for(int i=0;i<c;i++) {
    		list.add(i);
    		vector.add(i);
    	}
    }
    
    public static void main(String[] args) throws InterruptedException {
    	int threadCount = 10;
    	for(int i=0;i<threadCount;i++){
    		new Thread(){
    			public void run(){
    				long start = System.currentTimeMillis();
    				for(int i=0;i<c;i++) {
    					list.get(i);
    				}
    				System.out.println("ArrayList进行 "+c+" 次get操作，耗时："+(System.currentTimeMillis()-start)+" ms");
    			};
    		}.start();
    		
    		new Thread(){
    			public void run(){
    				long start = System.currentTimeMillis();
    				for(int i=0;i<c;i++) {
    					vector.get(i);
    				}
    				System.out.println("Vector进行 "+c+" 次get操作，耗时："+(System.currentTimeMillis()-start)+" ms");
    			};
    		}.start();
    	}
    	
    }
}

输出结果：

ArrayList进行 100000 次get操作，耗时：5 ms
ArrayList进行 100000 次get操作，耗时：2 ms
ArrayList进行 100000 次get操作，耗时：5 ms
ArrayList进行 100000 次get操作，耗时：7 ms
ArrayList进行 100000 次get操作，耗时：5 ms
ArrayList进行 100000 次get操作，耗时：10 ms
ArrayList进行 100000 次get操作，耗时：5 ms
ArrayList进行 100000 次get操作，耗时：15 ms
ArrayList进行 100000 次get操作，耗时：10 ms
ArrayList进行 100000 次get操作，耗时：11 ms
Vector进行 100000 次get操作，耗时：12 ms
Vector进行 100000 次get操作，耗时：22 ms
Vector进行 100000 次get操作，耗时：31 ms
Vector进行 100000 次get操作，耗时：37 ms
Vector进行 100000 次get操作，耗时：40 ms
Vector进行 100000 次get操作，耗时：43 ms
Vector进行 100000 次get操作，耗时：41 ms
Vector进行 100000 次get操作，耗时：44 ms
Vector进行 100000 次get操作，耗时：42 ms
Vector进行 100000 次get操作，耗时：45 ms

可以看出Vector的get操作比ArrayList耗时要多。这只是其中的一方面性能问题上的反映。

由于Vector中的add方法和get方法都进行了同步，因此，在有多个线程进行访问时，如果多个线程都只是进行读取操作，那么每个时刻就只能有一个线程进行读取，其他线程便只能等待，这些线程必须竞争同一把锁。

因此为了解决同步容器的性能问题，在Java 1.5中提供了并发容器，位于java.util.concurrent目录下，并发容器的相关知识后续讲解。

2）同步容器真的是安全的吗？

也有有人认为Vector中的方法都进行了同步处理，那么一定就是线程安全的，事实上这可不一定。看下面这段代码：

import java.util.Vector;

public class Test {

	private static final Vector<Integer> vector = new Vector<Integer>();
	
    public static void main(String[] args) throws InterruptedException {
        while(true) {
            for(int i=0;i<10;i++) {
            	vector.add(i);
            }
            
            Thread t1 = new Thread(){
                public void run() {
            		for(int i=0;i<vector.size();i++) {
            			vector.remove(i);
            		}
                };
            };
            Thread t2 = new Thread(){
                public void run() {
            		for(int i=0;i<vector.size();i++) {
            			vector.get(i);
            		}
                };
            };
            t1.start();
            t2.start();
        }
    }
}

输出结果：

我们看到这段代码报错了：数组下标越界。

也许有朋友会问：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的元素肯定就会出问题了。

因此为了保证线程安全，必须在方法调用端做额外的同步措施，如下面所示：

import java.util.Vector;

public class Test {

	private static final Vector<Integer> vector = new Vector<Integer>();
	
    public static void main(String[] args) throws InterruptedException {
        while(true) {
            for(int i=0;i<10;i++) {
            	vector.add(i);
            }
            
            Thread t1 = new Thread(){
                public void run() {
                	synchronized (Test.class) {   //进行额外的同步
                		for(int i=0;i<vector.size();i++) {
                			vector.remove(i);
                		}
                	}
                };
            };
            Thread t2 = new Thread(){
                public void run() {
                	synchronized (Test.class) {   //进行额外的同步
                		for(int i=0;i<vector.size();i++) {
                			vector.get(i);
                		}
                	}
                };
            };
            t1.start();
            t2.start();
        }
    }
}

3） ConcurrentModificationException异常

在对Vector等容器并发地进行迭代修改时，会报ConcurrentModificationException异常，关于这个异常后续会讲解，但是在并发容器中不会出现这个问题。

欢迎小伙伴们留言交流~~
浏览更多文章可关注微信公众号：diggkr