Java中的集合和线程安全

通过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异常。

我们来总结下今天我们所学到的几个点：

  1. 大部分在java.util包下的实现类都没有保证线程安全为了保证性能的优越，除了Vector和Hashtable以外。
  2. 通过Collection可以创建线程安全类，但是他们的性能都比较差。
  3. 同步集合既保证线程安全也在给予不同的算法上保证了性能，他们都在java.util.concurrent包中。?

翻译来自：
https://www.codejava.net/java-core/collections/understanding-collections-and-thread-safety-in-java

原文地址：https://www.cnblogs.com/deky97/p/11024527.html

时间： 2024-10-10 04:37:40

Java中的集合和线程安全的相关文章

Java中的集合与线程的Demo

一.简单线程同步问题 package com.ietree.multithread.sync; import java.util.Vector; public class Tickets { public static void main(String[] args) { // 初始化火车票池并添加火车票:避免线程同步可采用Vector替代ArrayList HashTable替代HashMap final Vector<String> tickets = new Vector<Stri

菜鸟日记之 java中的集合框架

java中的集合框架图 如图所示:java中的集合分为两种Collection和Map两种接口 可分为Collection是单列集合和Map的双列集合 Collection单列集合:继承了Iterator接口所以具有了iterator()方法 ,该方法返回一个Iterator<T>,这个接口具有 HasNext (),next(),remove()3个方法可以在实现类里完成实现. hasNext():判断是否有下一个元素 cusor是当前的操作下标 next():读取下一个元素 remove(

java中的集合操作类（未完待续）

申明: 实习生的肤浅理解,如发现有错误之处,还望大牛们多多指点 废话 其实我写java的后台操作,我每次都会遇到一条语句:List<XXXXX> list = new ArrayList<XXXXX>(); 但是我仅仅只是了解,list这个类是一个可变长用来存储的对象实例的类,我甚至觉得这个List对象可以理解成数组,但是却又与java中咱们正常理解的数组很多的不同,比如说,他的长度可以随着需要自动增长,比如说,实例化一个List类就和咱们声明数组的时候是不一样的! 今天的实习生活

java中各种集合的用法和比较

一,java中各种集合的关系图 Collection       接口的接口     对象的集合 ├ List             子接口         按进入先后有序保存   可重复 │├ LinkedList    接口实现类     链表     插入删除   没有同步   线程不安全 │├ ArrayList     接口实现类      数组     随机访问   没有同步   线程不安全 │└ Vector        接口实现类       数组              

Java中的集合框架-Map

前两篇<Java中的集合框架-Commection(一)>和<Java中的集合框架-Commection(二)>把集合框架中的Collection开发常用知识点作了一下记录,从本篇开始,对集合框架里的另外一部分Map作一下记录. 一,集合框架的Map接口 Map与Collection不同之处在于它是以键值对来存储数据: Map比较常用的实现类有四个:HashTable,HashMap,LinkedHashMap,TreeMap: Map的方法也可以分为四类,增删改查,大致如下: 新

java中的集合框架

由于数组具有属性单一,长度不可改变的缺点,于是在程序中我们使用集合来代替它. 集合中不可放入基本数据类型,基本数据类型都是通过自动拆包和自动装箱功能才能放入和取出集合. 分类:Collection接口和Map接口 Collection:存放单一值元素,又可分为list接口类型和set接口类型 list接口类型:存放元素是有序的可重复的,可通过循环来取出其中的元素,实现类ArrayList() set接口类型:hash值排列,存放元素是无序不可重复的,通过指针取出其中元素,实现类HashSet()

我对java中任务取消和线程中断的一点儿理解

在JDK中任务就是一个Runnable或Callable对象,线程是一个Thread对象,任务是运行在某个线程中的.我们知道,让线程死亡的方式有2种:正常完成和未捕获的异常.如果想让任务结束,也只有这2种方式. java中虽然提供了抢占式中断Thread.stop(),但这是很不安全的,JDK早已经将其标记成过时的了.在java中如果想取消一个任务,只能使用中断,中断是一种协作机制.也就是说,如果A线程想中断B线程,那么其实是A向B发送了一个中断请求,至于B到底会不会停止执行,取决于B的实现.如

Java中的进程和线程

 Java中的进程与线程 一:进程与线程 概述:几乎任何的操作系统都支持运行多个任务,通常一个任务就是一个程序,而一个程序就是一个进程.当一个进程运行时,内部可能包括多个顺序执行流,每个顺序执行流就是一个线程. 进程:进程是指处于运行过程中的程序,并且具有一定的独立功能.进程是系统进行资源分配和调度的一个单位.当程序进入内存运行时,即为进程. 进程的三个特点: 1:独立性:进程是系统中独立存在的实体,它可以独立拥有资源,每一个进程都有自己独立的地址空间,没有进程本身的运行,用户进程不可以直接访问

Java中的进程与线程（总结篇）

详细文档: Java中的进程与线程.rar 474KB 1/7/2017 6:21:15 PM 概述: 几乎任何的操作系统都支持运行多个任务,通常一个任务就是一个程序,而一个程序就是一个进程.当一个进程运行时,内部可能包括多个顺序执行流,每个顺序执行流就是一个线程. 进程与线程: 进程是指处于运行过程中的程序,并且具有一定的独立功能.进程是系统进行资源分配和调度的一个单位.当程序进入内存运行时,即为线程. 进程拥有以下三个特点: 1:独立性:进程是系统中独立存在的实体,它可以独立拥有资源,每一个