本文详细解析了线程安全与线程不安全的概念，探讨了多线程环境下数据访问的安全性问题，对比分析了Java中线程安全与非线程安全的集合类，如Vector与ArrayList，HashTable与HashMap，以及StringBuffer与StringBuilder等，阐述了它们的工作原理与适用场景。
1）线程安全和线程不安全理解
线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。 线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据
概念：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
或者说:一个类或者程序所提供的接口对于线程来说是原子操作或者多个线程之间的切换不会导致该接口的执行结果存在二义性,也就是说我们不用考虑同步的问题。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
安全性：
比如一个 ArrayList 类，在添加一个元素的时候，它可能会有两步来完成：1. 在 Items[Size] 的位置存放此元素；2. 增大 Size 的值。
在单线程运行的情况下，如果 Size = 0，添加一个元素后，此元素在位置 0，而且 Size=1；
而如果是在多线程情况下，比如有两个线程，线程 A 先将元素存放在位置 0。但是此时 CPU 调度线程A暂停，线程 B 得到运行的机会。线程B也向此 ArrayList 添加元素，因为此时 Size 仍然等于 0 （注意哦，我们假设的是添加一个元素是要两个步骤哦，而线程A仅仅完成了步骤1），所以线程B也将元素存放在位置0。然后线程A和线程B都继续运行，都增加 Size 的值。
那好，我们来看看 ArrayList 的情况，元素实际上只有一个，存放在位置 0，而 Size 却等于 2。这就是“线程不安全”了。
安全性：
线程安全性不是一个非真即假的命题。 Vector 的方法都是同步的，并且 Vector 明确地设计为在多线程环境中工作。但是它的线程安全性是有限制的，即在某些方法之间有状态依赖(类似地，如果在迭代过程中 Vector 被其他线程修改，那么由 Vector.iterator() 返回的 iterator会抛出ConcurrentModifiicationException)。
对于 Java 类中常见的线程安全性级别，没有一种分类系统可被广泛接受，不过重要的是在编写类时尽量记录下它们的线程安全行为。
Bloch 给出了描述五类线程安全性的分类方法：不可变、线程安全、有条件线程安全、线程兼容和线程对立。只要明确地记录下线程安全特性，那么您是否使用这种系统都没关系。这种系统有其局限性 -- 各类之间的界线不是百分之百地明确，而且有些情况它没照顾到 -- 但是这套系统是一个很好的起点。这种分类系统的核心是调用者是否可以或者必须用外部同步包围操作(或者一系列操作)。下面几节分别描述了线程安全性的这五种类别。
不可变
不可变的对象一定是线程安全的，并且永远也不需要额外的同步 。因为一个不可变的对象只要构建正确，其外部可见状态永远也不会改变，永远也不会看到它处于不一致的状态。Java 类库中大多数基本数值类如 Integer 、 String 和 BigInteger 都是不可变的。
需要注意的是，对于Integer，该类不提供add方法，加法是使用+来直接操作。而+操作是不具线程安全的。这是提供原子操作类AtomicInteger的原。
线程安全
线程安全的对象具有在上面“线程安全”一节中描述的属性 -- 由类的规格说明所规定的约束在对象被多个线程访问时仍然有效，不管运行时环境如何排线程都不需要任何额外的同步。这种线程安全性保证是很严格的 -- 许多类，如 Hashtable 或者 Vector 都不能满足这种严格的定义。
有条件的
有条件的线程安全类对于单独的操作可以是线程安全的，但是某些操作序列可能需要外部同步。条件线程安全的最常见的例子是遍历由 Hashtable 或者 Vector 或者返回的迭代器 -- 由这些类返回的 fail-fast 迭代器假定在迭代器进行遍历的时候底层集合不会有变化。为了保证其他线程不会在遍历的时候改变集合，进行迭代的线程应该确保它是独占性地访问集合以实现遍历的完整性。通常，独占性的访问是由对锁的同步保证的 -- 并且类的文档应该说明是哪个锁(通常是对象的内部监视器(intrinsic monitor))。
如果对一个有条件线程安全类进行记录，那么您应该不仅要记录它是有条件线程安全的，而且还要记录必须防止哪些操作序列的并发访问。用户可以合理地假设其他操作序列不需要任何额外的同步。
线程兼容
线程兼容类不是线程安全的，但是可以通过正确使用同步而在并发环境中安全地使用。这可能意味着用一个 synchronized 块包围每一个方法调用，或者创建一个包装器对象，其中每一个方法都是同步的(就像 Collections.synchronizedList() 一样)。也可能意味着用 synchronized 块包围某些操作序列。为了最大程度地利用线程兼容类，如果所有调用都使用同一个块，那么就不应该要求调用者对该块同步。这样做会使线程兼容的对象作为变量实例包含在其他线程安全的对象中，从而可以利用其所有者对象的同步。
许多常见的类是线程兼容的，如集合类 ArrayList 和 HashMap 、 java.text.SimpleDateFormat 、或者 JDBC 类 Connection 和 ResultSet 。
线程对立
线程对立类是那些不管是否调用了外部同步都不能在并发使用时安全地呈现的类。线程对立很少见，当类修改静态数据，而静态数据会影响在其他线程中执行的其他类的行为，这时通常会出现线程对立。线程对立类的一个例子是调用 System.setOut() 的类。
2）相关的一些类的理解
java中有些类实现功能大同小异，他们最大的区别就在于是否是线程安全的。
StringBuilder 与 StringBuffer
这两种类内部都维护了一个字符数组，不同于 String 类中的final所修饰的字符数组，这两种类都可不断地向字符数组中加入字符，也就是一种可变的字符序列。所以当需要进行大量的字符串拼接时可使用这两种类。
他们的区别在于， StringBuffer 是线程安全的，而 StringBuilder 是线程不安全的，造成这种区别的原因是StringBuffer中的方法都被 synchronized 所修饰。
Vector 与 ArrayList
这两种类都采用线性连续存储空间，即通过数组来存储数值，且他们都是 List 接口的实现类，List的实现类还有一个LinkedList
不同之处在于，
其一，Vector 是线程安全的，而 ArrayList 是线程不安全的，这同样是由于 Vector 的方法被 synchronized 所修饰而造成的。
其二，当存储空间不同时， Vector 默认增长至原来容量的 两倍 ，而 ArrayList 增长至原来的 1.5倍 。
其三， Vector 能通过 capacityIncrement 方法来设置每次增加多少存储容量，而 ArrayList 则不可以。
HashMap 与 Hashtable
这两种类都是通过hash算法来判断数据存储位置，且都实现了Map接口（Hashtable是在JDK4中被重写了，实现了Map接口），通过键值对的方式存储数据。
不同之处在于，
其一， HashMap 是线程不安全的， Hashtable 是线程安全的，同样是由于 Hashtable 的方法被 synchronized 修饰造成。
其二， HashMap 可以接收键值（key）为null或者value为null的键值对，而 Hashtable 不行。
其三， HashMap 与Hashtable的 迭代器 不同， HashMap 的迭代器是 Iterator 类型的，而 Hashtable 的迭代器是 Enumerator 类型的。
在 JDK5 中提供了 ConcurrentHashMap ，它也是线程安全的，它是Hashtable的替代品，他的扩展性比Hashtable更好。
以上几种类中线程安全的比线程不安全的执行速度更慢，当我们想要将线程不安全的类同步时，我们可以通过 Collections 的三个方法synchronizedList(list)，synchronizedSet(set)，synchronizedMap(map)来将其转为线程安全。
还有下边这些：
通过synchronized 关键字给方法加上内置锁来实现线程安全
Timer，TimerTask，Vector，Stack，HashTable，StringBuffer
原子类Atomicxxx—包装类的线程安全类
如AtomicLong，AtomicInteger等等
Atomicxxx 是通过Unsafe 类的native方法实现线程安全的
BlockingQueue 和BlockingDeque
BlockingDeque接口继承了BlockingQueue接口，
BlockingQueue 接口的实现类有ArrayBlockingQueue ，LinkedBlockingQueue ，PriorityBlockingQueue 而BlockingDeque接口的实现类有LinkedBlockingDeque
BlockingQueue和BlockingDeque 都是通过使用定义为final的ReentrantLock作为类属性显式加锁实现同步的
CopyOnWriteArrayList和 CopyOnWriteArraySet
CopyOnWriteArraySet的内部实现是在其类内部声明一个final的CopyOnWriteArrayList属性，并在调用其构造函数时实例化该CopyOnWriteArrayList，CopyOnWriteArrayList采用的是显式地加上ReentrantLock实现同步，而CopyOnWriteArrayList容器的线程安全性在于在每次修改时都会创建并重新发布一个新的容器副本，从而实现可变性。
Concurrentxxx
最常用的就是ConcurrentHashMap，当然还有ConcurrentSkipListSet和ConcurrentSkipListMap等等。
ConcurrentHashMap使用了一种完全不同的加锁策略来提供更高的并发性和伸缩性。ConcurrentHashMap并不是将每个方法都在同一个锁上同步并使得每次只能有一个线程访问容器，而是使用一种粒度更细的加锁机制——分段锁来实现更大程度的共享
在这种机制中，任意数量的读取线程可以并发访问Map，执行读取操作的线程和执行写入操作的线程可以并发地访问Map，并且一定数量的写入线程可以并发地修改Map，这使得在并发环境下吞吐量更高，而在单线程环境中只损失非常小的性能
ThreadPoolExecutor
ThreadPoolExecutor也是使用了ReentrantLock显式加锁同步
Collections中的synchronizedCollection(Collection c)方法可将一个集合变为线程安全，其内部通过synchronized关键字加锁同步
当然还有关于这些类的一些具体代码及其相关的讲解：
Java中集合类有很多，只介绍常用的集合类：
线程安全和非线程安全的集合对象
一、概念：
- 线程安全：就是当多线程访问时，采用了加锁的机制；即当一个线程访问该类的某个数据时，会对这个数据进行保护，其他线程不能对其访问，直到该线程读取完之后，其他线程才可以使用。防止出现数据不一致或者数据被污染的情况。
- 线程不安全：就是不提供数据访问时的数据保护，多个线程能够同时操作某个数据，从而出现数据不一致或者数据污染的情况。
- 对于线程不安全的问题，一般会使用synchronized关键字加锁同步控制。
- 线程安全工作原理： jvm中有一个main memory对象，每一个线程也有自己的working memory，一个线程对于一个变量variable进行操作的时候， 都需要在自己的working memory里创建一个copy,操作完之后再写入main memory。 当多个线程操作同一个变量variable，就可能出现不可预知的结果。
而用synchronized的关键是建立一个监控monitor，这个monitor可以是要修改的变量，也可以是其他自己认为合适的对象(方法)，然后通过给这个monitor加锁来实现线程安全，每个线程在获得这个锁之后，要执行完加载load到working memory 到 use && 指派assign 到 存储store 再到 main memory的过程。才会释放它得到的锁。这样就实现了所谓的线程安全。
二、线程安全(Thread-safe)的集合对象：
- Vector 线程安全：
- HashTable 线程安全：
- StringBuffer 线程安全：
三、非线程安全的集合对象：
- ArrayList ：
- LinkedList：
- HashMap：
- HashSet：
- TreeMap：
- TreeSet：
- StringBulider：
四、相关集合对象比较：
Vector、ArrayList、LinkedList：
1、Vector：
Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。
2、ArrayList：
a. 当操作是在一列数据的后面添加数据而不是在前面或者中间，并需要随机地访问其中的元素时，使用ArrayList性能比较好。
b. ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。
3、LinkedList：
a. 当对一列数据的前面或者中间执行添加或者删除操作时，并且按照顺序访问其中的元素时，要使用LinkedList。
b. LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。
Vector和ArrayList在使用上非常相似，都可以用来表示一组数量可变的对象应用的集合，并且可以随机的访问其中的元素。
ArryList和LinkedList的区别：
Vector与ArrayList比较：
1. 性能上
ArrayList底层数据结构是数组，适合随机查找和遍历，不适合插入和删除，线程不安全，效率高。。LinkedList底层数据结构是链表， 适合数据的动态插入和删除，随机访问和遍历速度比较慢，线程不安全，效率高。。
2. 同步性
Vectors是可同步的，是线程安全的。ArrayList是不可同步的，不是线程安全的。所以，一般单线程推荐用ArrayList，多线程中则用Vector
3. 数据增长
往一个ArrayList或者Vector里插入一个元素时，如果内部数组空间不够，ArrayList或Vector会扩展它的大小。Vector在默认情况下增长一倍的大小，而ArrayList增加50%的大小。
HashTable、HashMap、HashSet：
HashTable和HashMap采用的存储机制是一样的，不同的是：
1、HashMap：
a. 采用数组方式存储key-value构成的Entry对象，无容量限制；
b. 基于key hash查找Entry对象存放到数组的位置，对于hash冲突采用链表的方式去解决；
c. 在插入元素时，可能会扩大数组的容量，在扩大容量时须要重新计算hash，并复制对象到新的数组中；
d. 是非线程安全的；
e. 遍历使用的是Iterator迭代器；
2、HashTable：
a. 是线程安全的；
b. 无论是key还是value都不允许有null值的存在；在HashTable中调用Put方法时，如果key为null，直接抛出NullPointerException异常；
c. 遍历使用的是Enumeration列举；
3、HashSet：
a. 基于HashMap实现，无容量限制；
b. 是非线程安全的；
c. 不保证数据的有序；
TreeSet、TreeMap：
TreeSet和TreeMap都是完全基于Map来实现的，并且都不支持get(index)来获取指定位置的元素，需要遍历来获取。另外，TreeSet还提供了一些排序方面的支持，例如传入Comparator实现、descendingSet以及descendingIterator等。
1、TreeSet：
a. 基于TreeMap实现的，支持排序；
b. 是非线程安全的；
2、TreeMap：
a. 典型的基于红黑树的Map实现，因此它要求一定要有key比较的方法，要么传入Comparator比较器实现，要么key对象实现Comparator接口；
b. 是非线程安全的；
Collection有两个子接口：List和Set，二者主要区别在于：list数据有序存放、可重复；set中数据无序存放，不可重复。
Vector
Vector类实现了一个动态数组，主要用在事先不知道数组的大小，以及需要频繁地进行查找，插入，删除工作，或者只是需要一个可以改变大小的数组的情况。
创建：
Vector类支持4种构造方法。
第一种构造方法创建一个默认的向量，默认大小为10：
Vector()
第二种构造方法创建指定大小的向量。
Vector(int size)
第三种构造方法创建指定大小的向量，并且增量用incr指定. 增量表示向量每次增加的元素数目（当该vector对象添加的元素接近原先分配的内存极限时，会以incr大小自动扩大该对象拥有的内存容量，以容纳更多的数据）
Vector(int size,int incr)
第四中构造方法创建一个包含集合c元素的向量：利用父类对象创建子类对象
Vector(Collection c)
常用的vector操作方法：增、删、查、改。
增：
vec.add(E element)
将指定元素追加到此向量的末尾。
vec.add(int index, E element)
在此向量的指定位置插入指定的元素。
vec.addAll(Collection c)
将指定 Collection 中的所有元素按顺序追加到此向量的末尾。
vec.addAll(int index, Collection c)
在指定位置将指定 Collection 中的所有元素插入到此向量中。
删：
vec.remove(int index)
移除此向量中指定位置的元素。
vec.remove(value v)
移除向量中元素值为v的元素。
vec.removeAll(Collection c)
从此向量中移除包含在集合c 中的所有元素。
vec.removeAllElements()
从此向量中移除全部组件，并将其大小设置为零。
vec.removeRange(int fromIndex, int toIndex)
移除位于 fromIndex（包括）与 toIndex（不包括）之间的所有元素。
vec.clear() 移除所有元素。
查：
vec.get(int index)
返回向量中指定位置的元素。
vex.indexOf(value v)
返回v值在vec中的下标。
vec.isEmpty()
检查该向量是否为空。
vec.lastElement()
返回此向量的最后一个元素。
int capacity()
返回此向量的当前容量。
int size()
返回此向量中的组件数。
String toString()
返回此向量的字符串表示形式，其中包含每个元素的 String 表示形式。
改：
vec.set(int index, E element)
用指定的元素替换此向量中指定位置处的元素。
vex.setElementAt(E obj, int index)
将此向量指定 index 处的组件设置为指定的对象。
vec.setSize(int newSize)
设置此向量的大小。
ArrayList
ArrayList就是动态的数组，可以动态的增加和减少元素，灵活的设置数组的大小。基本与Vector一样。
创建：
ArrayList提供了三个构造器：
public ArrayList();
默认的构造器，将会以默认（16）的大小来初始化内部的数组
public ArrayList(Collection c);
用一个集合对象来构造，并将该集合的元素添加到ArrayList
public ArrayList(int n);
用指定n的大小来初始化内部的数组.
增：
| 方法摘要 | |
|---|---|
boolean | add(E e) 将指定的元素添加到此列表的尾部。 |
void | add(int index, E element) 将指定的元素插入此列表中的指定位置。 |
boolean | addAll(Collection<? extends E> c) 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 |
boolean | addAll(int index, Collection<? extends E> c) 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 |
删：
E | remove(int index) 移除此列表中指定位置上的元素。 |
boolean | remove(Object o) 移除此列表中首次出现的指定元素（如果存在）。 |
protected void | removeRange(int fromIndex, int toIndex) 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 |
void | clear() 移除此列表中的所有元素。 |
查：
E | get(int index) 返回此列表中指定位置上的元素。 |
int | indexOf(Object o) 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。 |
boolean | isEmpty() 如果此列表中没有元素，则返回 true |
int | size() 返回此列表中的元素数。 |
boolean | contains(Object o) 如果此列表中包含指定的元素，则返回 true。 |
ArrayList支持3种遍历方式
第一种，通过迭代器遍历。
Integer value = null;
Iterator iter = list.iterator();
while (iter.hasNext()) {
value = (Integer)iter.next();
}
第二种，随机访问，通过索引值去遍历。
Integer value = null;for (int i=0; i<list.size(); i++) {
value = (Integer)list.get(i);
}
第三种，for-each遍历。
Integer value = null;
for (Integer integ:list) {
value = integ;
}
改：
E | set(int index, E element) 用指定的元素替代此列表中指定位置上的元素。 |
Object[] | toArray() |
HashMap
这里我们先讲hashmap，具体原因等讲到hashset的时候就知道了。
HashMap基于哈希表的 Map 接口实现，以key-value的形式存在。在HashMap中，系统 key-value 当成一个整体进行处理，系统总是根据 Hash 算法来计算 key-value 的存储位置，这样可以保证能快速存、取 Map 的 key-value 对。系统调用key的 hashCode() 方法得到其 hashCode 值——每个 Java 对象都有 hashCode() 方法，都可通过该方法获得它的 hashCode 值。得到这个对象的 hashCode 值之后，系统会根据该 hashCode 值来决定key—value的存储位置。
创建：
| 构造方法摘要 | |
|---|---|
HashMap() 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 | |
HashMap(int initialCapacity) 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap。 | |
HashMap(int initialCapacity, float loadFactor) 构造一个带指定初始容量和加载因子的空 HashMap。 | |
HashMap(Map<? extends K,? extends V> m) 构造一个映射关系与指定 Map 相同的 HashMap。 | |
容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。
增：
V | put(K key, V value) 插入键值对。 |
void | putAll(Map<? extends K,? extends V> m) 把map中的键值对插入到hashmap中。 |
删：
V | remove(Object key) 如果此映射中存在该键的映射关系，则将其删除。 |
void |
|
查：
V | get(Object key) 返回指定键在此标识哈希映射中所映射的值，如果对于此键来说，映射不包含任何映射关系，则返回 null。 |
boolean | isEmpty() 如果此映射不包含键-值映射关系，则返回 true。 |
Set<K> | keySet() 返回此映射中所包含的键的 set 。//获取hashmap中的key集合。 |
Collection<V> | values() 返回此映射所包含的值的 collection 视图。 |
int | size() 返回此映射中的键-值映射关系数。 |
boolean | containsKey(Object key) 如果此映射包含对于指定的键的映射关系，则返回 true。 |
boolean | containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。 |
HashSet
HashSet是基于 HashMap 实现的，底层采用 HashMap 来保存数据。所有放入 HashSet 中的集合元素实际上由 HashMap 的 key 来保存，而 HashMap 的 value 则存储了一个静态的 Object 对象（向上转型，这样value就可以是各种基本类型的值了）。HashSet 的绝大部分方法都是通过调用 HashMap 的方法来实现的，因此 HashSet 和 HashMap 两个集合在实现本质上是相同的。
创建：
HashSet hashSet = new HashSet();
HashSet hashset=new HashSet(collection);
增：
hashset.add(value);//向集合中添加一个元素
hashset.add(array[]);//把数组中的值添加到集合中
删：
删除一个元素：hashSet.remove(Object);
删除所有元素：hashSet.clear();
查：
用迭代器遍历：
Iterator it = hashSet.iterator();
while(it.hasNext()){
Object obj = it.next();
然后针对obj进行一系列的操作，比如：输出值、如果obj是类对象则调用属性、方法。
｝
boolean | contains(Object o) 如果此 set 包含指定元素，则返回 true。 |
boolean | isEmpty() 如果此 set 不包含任何元素，则返回 true。 |
int | size() 返回此 set 中的元素的数量（set 的容量）。 |
当从HashSet中访问元素时，HashSet先计算该元素的hashCode值（也就是调用该对象的hashCode（））方法的返回值），然后直接到该hashCode对应的位置去取出该元素。 为了保证HashSet能正常工作，要求当两个对象用equals比较相等时，hashCode也要相等，否则就会有可能加入两个相同的项。
HashSet的特点：
（1）HashSet不是同步的，多个线程访问是需要通过代码保证同步
（2）集合元素值可以为null。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
