深入Java集合学习系列:CopyOnWriteArrayList详解
2015-10-13 17:08
721 查看
/article/3466948.html
/article/3486847.html
CopyOnWriteArrayList是ArrayList 的一个线程安全的变体,其中所有可变操作(add、set等等)都是通过对底层数组进行一次新的复制来实现的。
这种情况一般在多线程操作时,一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。
下面来看一个列子:两个线程一个线程fore一个线程修改list的值。
?
package
com.lucky.concurrent.list;
import
java.util.ArrayList;
import
java.util.List;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
public
class
CopyOnWriteArrayListDemo {
读线程
@author wangjie
static
class
ReadTask implements
Runnable {
list;
ReadTask(List list) {
= list;
void
run() {
(String str : list) {
写线程
@author wangjie
static
class
WriteTask implements
Runnable {
list;
index;
WriteTask(List list, int
index) {
= list;
= index;
void
run() {
“write_”
index);
}public
void
run() {
int
NUM = 10;
list = new
ArrayList();
(int
i = 0;
i < NUM; i++) {
i);
executorService = Executors.newFixedThreadPool(NUM);
(int
i = 0;
i < NUM; i++) {
ReadTask(list));
WriteTask(list, i));
static
void
main(String[] args) {
CopyOnWriteArrayListDemo().run();
}运行结果:
从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果:那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码:
?
/**
Appends the specified element to the end of this list.
@param e element to be appended to this list
@return true (as specified by {@link Collection#add})
public
boolean
add(E e) {
final
ReentrantLock lock = this.lock;
lock.lock();
try
{
elements = getArray();
len = elements.length;
newElements = Arrays.copyOf(elements, len + 1);
= e;
true;
}finally
{
}}用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码:
?
//
List list = new ArrayList();
list = new
CopyOnWriteArrayList();
也就把容器list换成了 CopyOnWriteArrayList,其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list 接口。看结果:
其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。
所以最后得出结论:CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里,比如缓存。发生修改时候做copy,新老版本分离,保证读的高性能,适用于以读为主的情况。
?
/* The lock protecting all mutators /
这两个成员变量是该类的核心,对集合所有的修改操作都需要使用lock加锁,array则是整个集合的数据储存部分,关键在于该array被声明为volatile,当一个线程对与线程中array副本的修改会立即同步到主内存中该变量中去。
?
public CopyOnWriteArrayList(Collection
/article/3486847.html
CopyOnWriteArrayList是ArrayList 的一个线程安全的变体,其中所有可变操作(add、set等等)都是通过对底层数组进行一次新的复制来实现的。
这一般需要很大的开销,但是当遍历操作的数量大大超过可变操作的数量时,这种方法可能比其他替代方法更 有效。在不能或不想进行同步遍历,但又需要从并发线程中排除冲突时,它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改,因此不可能发生冲突,并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后,迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作(remove、set和add)不受支持。这些方法将抛出UnsupportedOperationException。允许使用所有元素,包括null。 内存一致性效果:当存在其他并发 collection 时,将对象放入CopyOnWriteArrayList之前的线程中的操作 happen-before 随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。
这种情况一般在多线程操作时,一个线程对list进行修改。一个线程对list进行fore时会出现java.util.ConcurrentModificationException错误。
下面来看一个列子:两个线程一个线程fore一个线程修改list的值。
?
package
com.lucky.concurrent.list;
import
java.util.ArrayList;
import
java.util.List;
import
java.util.concurrent.ExecutorService;
import
java.util.concurrent.Executors;
public
class
CopyOnWriteArrayListDemo {
/** *
读线程
*
@author wangjie
**/
private
static
class
ReadTask implements
Runnable {
List<String>
list;
public
ReadTask(List list) {
this.list
= list;
} public
void
run() {
for
(String str : list) {
System.out.println(str);
}}}/** *
写线程
*
@author wangjie
**/
private
static
class
WriteTask implements
Runnable {
List<String>
list;
int
index;
public
WriteTask(List list, int
index) {
this.list
= list;
this.index
= index;
} public
void
run() {
list.remove(index); list.add(index,
“write_”
index);
}
}public
void
run() {
final
int
NUM = 10;
List<String>
list = new
ArrayList();
for
(int
i = 0;
i < NUM; i++) {
list.add("main_"
i);
}ExecutorService
executorService = Executors.newFixedThreadPool(NUM);
for
(int
i = 0;
i < NUM; i++) {
executorService.execute(new
ReadTask(list));
executorService.execute(new
WriteTask(list, i));
}executorService.shutdown();
}public
static
void
main(String[] args) {
new
CopyOnWriteArrayListDemo().run();
}
}运行结果:
从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果:那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码:
?
/**
*
Appends the specified element to the end of this list.
**
@param e element to be appended to this list
*
@return true (as specified by {@link Collection#add})
*/
public
boolean
add(E e) {
final
ReentrantLock lock = this.lock;
lock.lock();
try
{
Object[]
elements = getArray();
int
len = elements.length;
Object[]
newElements = Arrays.copyOf(elements, len + 1);
newElements[len]
= e;
setArray(newElements); return
true;
}finally
{
lock.unlock();
}}用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
换了种方案看代码:
?
//
List list = new ArrayList();
CopyOnWriteArrayList<String>
list = new
CopyOnWriteArrayList();
也就把容器list换成了 CopyOnWriteArrayList,其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list 接口。看结果:
其结果没报错。
CopyOnWriteArrayList add(E) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。
所以最后得出结论:CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里,比如缓存。发生修改时候做copy,新老版本分离,保证读的高性能,适用于以读为主的情况。
CopyOnWriteArrayList类是高效的线程安全的类。线程安全是因为该类对于所有的修改方法都使用了加锁操作。高效是因为对于迭代操作是对原有集合的引用,避免了同步的开销。
?
/* The lock protecting all mutators /
transient final ReentrantLock lock = new ReentrantLock();
/** The array, accessed only via getArray/setArray. */
private volatile transient Object[] array;
这两个成员变量是该类的核心,对集合所有的修改操作都需要使用lock加锁,array则是整个集合的数据储存部分,关键在于该array被声明为volatile,当一个线程对与线程中array副本的修改会立即同步到主内存中该变量中去。
?
public CopyOnWriteArrayList(Collection
相关文章推荐
- java获得系统当前时间三种方式及日期格式之间的相互转化
- java中定时任务 quartz 时间配置规则
- 深入Java集合学习系列:ArrayList的实现原理
- java时间推算
- java jxl 向Excel中追加数据而不覆盖原来数据的例子
- synchronized的使用方法
- 使用java写入excel文件
- 偏执却管用的10条Java编程技巧
- eclipse调整字体大小
- [Java]Spring数据库事务基础知识
- java中的包package
- ***5.33-当前日期与时间
- 韩顺平 java 第40讲 线程同步
- java入门第四天 游戏准备 跳来跳去 的小球
- springMVC 与 struts2的区别
- java对视频进行截图
- Lunix下如何查看lunix版本和Weblogic/JDK版本
- 对Java JVM中类加载几点解释
- KMP算法的java实现
- spring的Aop使用问题