集合操作 Demo
package com.thr_safety;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class ThreadDemo3 {
public static void main(String[] args) {
//建立一个ArrayList 集合
List<String> list = new ArrayList<>();
for (int i = 0; i < 30; i++) {
//在循环中添加线程
new Thread( () -> {
//在线程中将随机数添加到集合中(ArrayList)
list.add( UUID.randomUUID().toString().substring( 0, 8 ) );
System.out.println( list );
}, String.valueOf( i ) ).start();
}
//会生成java.util.ConcurrentModificationException
//并发修改异常
/**
* 生成并发修改异常的原因是因为add方法中没有synchronized关键字
*/
}
}
运行之后会生成java.util.ConcurrentModificationException，俗称并发修改异常
我们看一下add方法
/**
* Appends the specified element to the end of this list.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
此时我们发现add方法中没有synchronized关键字
那么我们如何去解决 List 类型的线程安全问题?
Vector
Vector 是矢量队列，它是 JDK1.0 版本添加的类。继承于 AbstractList，实现了 List, RandomAccess, Cloneable 这些接口。 Vector 继承了 AbstractList，实现了 List；所以，它是一个队列，支持相关的添加、删除、修改、遍历等功能。 Vector 实现了 RandmoAccess 接口，即提供了随机访问功能。RandmoAccess 是 java 中用来被 List 实现，为 List 提供快速访问功能的。在Vector 中，我们即可以通过元素的序号快速获取元素对象；这就是快速随机访问。 Vector 实现了 Cloneable 接口，即实现 clone()函数。它能被克隆。
和 ArrayList 不同，Vector 中的操作是线程安全的。
package com.thr_safety;
import java.util.UUID;
import java.util.Vector;
public class NotSafeDemo {
public static void main(String[] args) {
Vector<String> vector = new Vector<>();
for (int i = 0; i < 30; i++) {
new Thread( () ->{
vector.add( UUID.randomUUID().toString().substring( 0,8 ) );
System.out.println(vector);
},String.valueOf( i )).start();
}
}
}
此时控制台输出没有问题，那么原理是什么呢？
我们看一下Vector类中的add方法
/**
* Appends the specified element to the end of this Vector.
*
* @param e element to be appended to this Vector
* @return {@code true} (as specified by {@link Collection#add})
* @since 1.2
*/
public synchronized boolean add(E e) {
modCount++;
ensureCapacityHelper(elementCount + 1);
elementData[elementCount++] = e;
return true;
}
add 方法被 synchronized 同步修饰,线程安全!因此没有并发异常
Collections
Collections 提供了方法 synchronizedList 保证 list 是同步线程安全的
package com.thr_safety;
import java.util.*;
public class NotSafeDemo1 {
public static void main(String[] args) {
List<String> list = Collections.synchronizedList( new ArrayList<>() );
for (int i = 0; i < 30; i++) {
new Thread( () -> {
list.add( UUID.randomUUID().toString().substring( 0, 8 ) );
System.out.println( list );
}, String.valueOf( i ) ).start();
}
}
}
没有并发修改异常
查看方法源码
/**
* Returns a synchronized (thread-safe) list backed by the specified
* list. In order to guarantee serial access, it is critical that
* <strong>all</strong> access to the backing list is accomplished
* through the returned list.<p>
*
* It is imperative that the user manually synchronize on the returned
* list when iterating over it:
* <pre>
* List list = Collections.synchronizedList(new ArrayList());
* ...
* synchronized (list) {
* Iterator i = list.iterator(); // Must be in synchronized block
* while (i.hasNext())
* foo(i.next());
* }
* </pre>
* Failure to follow this advice may result in non-deterministic behavior.
*
* <p>The returned list will be serializable if the specified list is
* serializable.
*
* @param <T> the class of the objects in the list
* @param list the list to be "wrapped" in a synchronized list.
* @return a synchronized view of the specified list.
*/
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<>(list) :
new SynchronizedList<>(list));
}
方法表明 synchronizedList 方法 也是 List 接口中的方法，在里面可以传递List接口中的对象
CopyOnWriteArrayList(重点)
首先我们对 CopyOnWriteArrayList 进行学习,其特点如下:
它相当于线程安全的 ArrayList。和 ArrayList 一样，它是个可变数组；但是和
ArrayList 不同的时，它具有以下特性：
1, 它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突。
2,它是线程安全的。
3,因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大。
4, 迭代器支持 hasNext(), next()等不可变操作，但不支持可变 remove()等操作。
5, 使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照。
1,独占锁效率低：采用读写分离思想解决
2,写线程获取到锁，其他写线程阻塞
3,复制思想：
当我们往一个容器添加元素的时候，不直接往当前容器添加，而是先将当前容器进行 Copy，复制出一个新的容器，然后新的容器里添加元素，添加完元素之后，再将原容器的引用指向新的容器。这时候会抛出来一个新的问题，也就是数据不一致的问题。如果写线程还没来得及写会内存，其他的线程就会读到了脏数据。
这就是 CopyOnWriteArrayList 的思想和原理。就是拷贝一份。
通俗讲：
CopyWriteArrayList 写时复制技术
开始时，在集合中并发读取，当想写入内容的时候将最开始的读取内容复制一份，之后独立的在复制一份的内容，重新写入新的内容。
package com.thr_safety;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArrayList;
public class NotSafeDemo2 {
public static void main(String[] args) {
List<Object> list = new CopyOnWriteArrayList<>();
for (int i = 0; i < 30; i++) {
new Thread( () -> {
list.add( UUID.randomUUID().toString().substring( 0, 8 ) );
System.out.println( list );
}, String.valueOf( i ) ).start();
}
}
}
HashSet 例子
package com.thr_safety;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CopyOnWriteArraySet;
public class NotSafeDemo3 {
//测试HashSet 线程问题
public static void main(String[] args) {
//异常
// Set<String> set = new HashSet<>();
//解决方式
Set<String> set = new CopyOnWriteArraySet<>();
for (int i = 0; i < 30; i++) {
new Thread(() ->{
set.add( UUID.randomUUID().toString().substring( 0,8 ) );
System.out.println(set);
},String.valueOf( i )).start();
}
}
}
HashMap例子
package com.thr_safety;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
public class NotSafeDemo4 {
public static void main(String[] args) {
//测试 HashMap 线程安全问题
// HashMap<String, String> map = new HashMap<>();
//解决并发修改异常问题
Map<String, String> map = new ConcurrentHashMap<>();
for (int i = 0; i < 30; i++) {
String key = String.valueOf( i );
new Thread( () -> {
map.put( key, UUID.randomUUID().toString().substring( 0,8 ) );
System.out.println(map);
},String.valueOf( i )).start();
}
}
}
没有线程安全问题
原因分析(重点):动态数组与线程安全
下面从“动态数组”和“线程安全”两个方面进一步对CopyOnWriteArrayList 的原理进行说明。
"动态数组”机制
- 它内部有个“volatile 数组”(array)来保持数据。在“添加/修改/删除”数据时，都会新建一个数组，并将更新后的数据拷贝到新建的数组中，最后再将该数组赋值给“volatile 数组”, 这就是它叫做 CopyOnWriteArrayList 的原因
- 由于它在“添加/修改/删除”数据时，都会新建数组，所以涉及到修改数据的操作，CopyOnWriteArrayList 效率很低；但是单单只是进行遍历查找的话，效率比较高。
“线程安全”机制
- 通过 volatile 和互斥锁来实现的。
- 通过“volatile 数组”来保存数据的。一个线程读取 volatile 数组时，总能看到其它线程对该 volatile 变量最后的写入；就这样，通过 volatile 提供了“读取到的数据总是最新的”这个机制的保证。
- 通过互斥锁来保护数据。在“添加/修改/删除”数据时，会先“获取互斥锁”，再修改完毕之后，先将数据更新到“volatile 数组”中，然后再“释放互斥锁”，就达到了保护数据的目的。
小结(重点)
1.线程安全与线程不安全集合
集合类型中存在线程安全与线程不安全的两种,常见例如:
ArrayList ----- Vector
HashMap -----HashTable
但是以上都是通过 synchronized 关键字实现,效率较低
2.Collections 构建的线程安全集合
3.java.util.concurrent 并发包下
CopyOnWriteArrayList CopyOnWriteArraySet 类型,通过动态数组与线程安全个方面保证线程安全
END
扫一扫
570
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
