通过 Java 指南我们知道 Java 集合框架 (Collection Framework) 如何为并发服务, 我们应该如何在单线程和多线程中使用集合(Collection).
话题有点高端, 我们不是很好理解. 所以, 我会尽可能的描述的简单点. 通过这篇指南, 你将会对 Java 集合由更深入的了解, 而且我敢保证, 这会对你的日常编码非常有用.
1. 为什么大多数的集合类不是线程安全的?
你注意到了吗? 为什么多数基本集合实现类都不是线程安全的? 比如: ArrayList, LinkedList, HashMap, HashSet, TreeMap, TreeSet 等等. 事实上, 所有的集合类 (除了 Vector 和 HashTable 以外) 在 java.util 包中都不是线程安全的, 只遗留了两个实现类 (Vector 和 HashTable) 是线程安全的为什么?
原因是: 线程安全消耗十分昂贵!
你应该知道, Vector 和 HashTable 在 Java 历史中, 很早就出现了, 最初的时候他们是为线程安全设计的.(如果你看了源码, 你会发现这些实现类的方法都被 synchronized 修饰)而且很快的他们在多线程中性能表现的非常差. 如你所知的, 同步就需要锁, 有锁就需要时间来监控, 所以就降低了性能.
这就是为什么新的集合类没有提供并发控制, 为了保证在单线程中提供最大的性能.
下面测试的程序验证了 Vector 和 ArrayList 的性能, 两个相似的集合类(Vector 是线程安全, ArrayList 非线程安全)
- import java.util.*;
- /**
- * This test program compares performance of Vector versus ArrayList
- * @author www.codejava.NET
- *
- */
- public class CollectionsThreadSafeTest {
- public void testVector() {
- long startTime = System.currentTimeMillis();
- Vector<Integer> vector = new Vector<>();
- for (int i = 0; i <10_000_000; i++) {
- vector.addElement(i);
- }
- long endTime = System.currentTimeMillis();
- long totalTime = endTime - startTime;
- System.out.println("Test Vector:" + totalTime + "ms");
- }
- public void testArrayList() {
- long startTime = System.currentTimeMillis();
- List<Integer> list = new ArrayList<>();
- for (int i = 0; i <10_000_000; i++) {
- list.add(i);
- }
- long endTime = System.currentTimeMillis();
- long totalTime = endTime - startTime;
- System.out.println("Test ArrayList:" + totalTime + "ms");
- }
- public static void main(String[] args) {
- CollectionsThreadSafeTest tester = new CollectionsThreadSafeTest();
- tester.testVector();
- tester.testArrayList();
- }
- }
通过为每个集合添加 1000 万个元素来测试性能, 结果如下:
- Test Vector: 9266 ms
- Test ArrayList: 4588 ms
如你所看到的, 在相当大的数据操作下, ArrayList 速度差不多是 Vector 的 2 倍. 你也拷贝上述代码自己感受下.
2. 快速失败迭代器(Fail-Fast Iterators)
在使用集合的时候, 你也要了解到迭代器的并发策略: Fail-Fast Iterators
看下以后代码片段, 遍历一个 String 类型的集合:
- List<String> listNames = Arrays.asList("Tom", "Joe", "Bill", "Dave", "John");
- Iterator<String> iterator = listNames.iterator();
- while (iterator.hasNext()) {
- String nextName = iterator.next();
- System.out.println(nextName);
- }
这里我们使用了 Iterator 来遍历 list 中的元素, 试想下 listNames 被两个线程共享: 一个线程执行遍历操作, 在还没有遍历完成的时候, 第二线程进行修改集合操作(添加或者删除元素), 你猜测下这时候会发生什么?
遍历集合的线程会立刻抛出异常 "ConcurrentModificationException", 所以称之为: 快速失败迭代器(随便翻的哈, 没那么重要, 理解就 OK)
为什么迭代器会如此迅速的抛出异常?
因为当一个线程在遍历集合的时候, 另一个在修改遍历集合的数据会非常的危险: 集合可能在修改后, 有更多元素了, 或者减少了元素又或者一个元素都没有了. 所以在考虑结果的时候, 选择抛出异常. 而且这应该尽可能早的被发现, 这就是原因.(反正这个答案不是我想要的~)
下面这段代码演示了抛出: ConcurrentModificationException
- import java.util.*;
- /**
- * This test program illustrates how a collection's iterator fails fast
- * and throw ConcurrentModificationException
- * @author www.codejava.NET
- *
- */
- public class IteratorFailFastTest {
- private List<Integer> list = new ArrayList<>();
- public IteratorFailFastTest() {
- for (int i = 0; i <10_000; i++) {
- list.add(i);
- }
- }
- public void runUpdateThread() {
- Thread thread1 = new Thread(new Runnable() {
- public void run() {
- for (int i = 10_000; i < 20_000; i++) {
- list.add(i);
- }
- }
- });
- thread1.start();
- }
- public void runIteratorThread() {
- Thread thread2 = new Thread(new Runnable() {
- public void run() {
- ListIterator<Integer> iterator = list.listIterator();
- while (iterator.hasNext()) {
- Integer number = iterator.next();
- System.out.println(number);
- }
- }
- });
- thread2.start();
- }
- public static void main(String[] args) {
- IteratorFailFastTest tester = new IteratorFailFastTest();
- tester.runIteratorThread();
- tester.runUpdateThread();
- }
- }
如你所见, 在 thread1 遍历 list 的时候, thread2 执行了添加元素的操作, 这时候异常被抛出.
需要注意的是, 使用 iterator 遍历 list, 快速失败的行为是为了让我更早的定位问题所在. 我们不应该依赖这个来捕获异常, 因为快速失败的行为是没有保障的. 这意味着如果抛出异常了, 程序应该立刻终止行为而不是继续执行.
现在你应该了解到了 ConcurrentModificationException 是如何工作的, 而且最好是避免它.
同步封装器
至此我们明白了, 为了确保在单线程环境下的性能最大化, 所以基础的集合实现类都没有保证线程安全. 那么如果我们在多线程环境下如何使用集合呢?
当然我们不能使用线程不安全的集合在多线程环境下, 这样做会导致出现我们期望的结果. 我们可以手动自己添加 synchronized 代码块来确保安全, 但是使用自动线程安全的线程比我们手动更为明智.
你应该已经知道, Java 集合框架提供了工厂方法创建线程安全的集合, 这些方法的格式如下:
Collections.synchronizedXXX(collection)
这个工厂方法封装了指定的集合并返回了一个线程安全的集合. XXX 可以是 Collection,List,Map,Set,SortedMap 和 SortedSet 的实现类. 比如下面这段代码创建了一个线程安全的列表:
List<String> safeList = Collections.synchronizedList(new ArrayList<>());
如果我们已经拥有了一个线程不安全的集合, 我们可以通过以下方法来封装成线程安全的集合:
- Map<Integer, String> unsafeMap = new HashMap<>();
- Map<Integer, String> safeMap = Collections.synchronizedMap(unsafeMap);
如你锁看到的, 工厂方法封装指定的集合, 返回一个线程安全的结合. 事实上接口基本都一直, 只是实现上添加了 synchronized 来实现. 所以被称之为: 同步封装器. 后面集合的工作都是由这个封装类来实现.
提示:
在我们使用 iterator 来遍历线程安全的集合对象的时候, 我们还是需要添加 synchronized 字段来确保线程安全, 因为 Iterator 本身并不是线程安全的, 请看代码如下:
- List<String> safeList = Collections.synchronizedList(new ArrayList<>());
- // adds some elements to the list
- Iterator<String> iterator = safeList.iterator();
- while (iterator.hasNext()) {
- String next = iterator.next();
- System.out.println(next);
- }
事实上我们应该这样来操作:
- synchronized (safeList) {
- while (iterator.hasNext()) {
- String next = iterator.next();
- System.out.println(next);
- }
- }
同时提醒下, Iterators 也是支持快速失败的.
尽管经过类的封装可保证线程安全, 但是他们依然有着自己的缺点, 具体见下面部分.
并发集合
一个关于同步集合的缺点是, 用集合的本身作为锁的对象. 这意味着, 在你遍历对象的时候, 这个对象的其他方法已经被锁住, 导致其他的线程必须等待. 其他的线程无法操作当前这个被锁的集合, 只有当执行的线程释放了锁. 这会导致开销和性能较低.
这就是为什么 jdk1.5 + 以后提供了并发集合的原因, 因为这样的集合性能更高. 并发集合类并放在 java.util.concurrent 包下, 根据三种安全机制被放在三个组中.
第一种为: 写时复制集合: 这种集合将数据放在一成不变的数组中; 任何数据的改变, 都会重新创建一个新的数组来记录值. 这种集合被设计用在, 读的操作远远大于写操作的情景下. 有两个如下的实现类: CopyOnWriteArrayList 和 CopyOnWriteArraySet.
需要注意的是, 写时复制集合不会抛出 ConcurrentModificationException 异常. 因为这些集合是由不可变数组支持的, Iterator 遍历值是从不可变数组中出来的, 不用担心被其他线程修改了数据.
第二种为: 比对交换集合也称之为 CAS(Compare-And-Swap)集合: 这组线程安全的集合是通过 CAS 算法实现的. CAS 的算法可以这样理解:
为了执行计算和更新变量, 在本地拷贝一份变量, 然后不通过获取访问来执行计算. 当准备好去更新变量的时候, 他会跟他之前的开始的值进行比较, 如果一样, 则更新值.
如果不一样, 则说明应该有其他的线程已经修改了数据. 在这种情况下, CAS 线程可以重新执行下计算的值, 更新或者放弃. 使用 CAS 算法的集合有: ConcurrentLinkedQueue and ConcurrentSkipListMap.
需要注意的是, CAS 集合具有不连贯的 iterators, 这意味着自他们创建之后并不是所有的改变都是从新的数组中来. 同时他也不会抛出 ConcurrentModificationException 异常.
第三种为: 这种集合采用了特殊的对象锁(java.util.concurrent.lock.Lock): 这种机制相对于传统的来说更为灵活, 可以如下理解:
这种锁和经典锁一样具有基本的功能, 但还可以再特殊的情况下获取: 如果当前没有被锁, 超时, 线程没有被打断.
不同于 synchronization 的代码, 当方法在执行, Lock 锁一直会被持有, 直到调用 unlock 方法. 有些实现通过这种机制把集合分为好几个部分来提供并发性能. 比如: LinkedBlockingQueue, 在队列的开后和结尾, 所以在添加和删除的时候可以同时进行.
其他使用了这种机制的集合有: ConcurrentHashMap 和绝多数实现了 BlockingQueue 的实现类
同样的这一类的集合也具有不连贯的 iterators, 也不会抛出 ConcurrentModificationException 异常.
我们来总结下今天我们所学到的几个点:
大部分在 java.util 包下的实现类都没有保证线程安全为了保证性能的优越, 除了 Vector 和 Hashtable 以外.
通过 Collection 可以创建线程安全类, 但是他们的性能都比较差.
同步集合既保证线程安全也在给予不同的算法上保证了性能, 他们都在 java.util.concurrent 包中.
喜欢这篇文章的朋友可以点个喜欢, 也可以关注一下我的个人专题: Java 成长之路
来源: http://www.jianshu.com/p/b8c8f6ca5d11