程序博客网 > 竞拍源码

Java 7之多线程并发容器

来源：互联网 发布：竞拍源码 编辑：程序博客网 时间：2024/05/22 13:15
CopyOnWriteArrayList相当于线程安全的ArrayList，通过增加写时复制语义来实现线程安全性。底层也是通过一个可变数组来实现的。但是和ArrayList不同的时，它具有以下特性：
  1.  它最适合于具有以下特征的应用程序：List 大小通常保持很小，只读操作远多于可变操作，需要在遍历期间防止线程间的冲突
  2.  支持高效率并发且是线程安全的
  3.  因为通常需要复制整个基础数组，所以可变操作（add()、set() 和 remove() 等等）的开销很大
  4.  迭代器支持hasNext(), next()等不可变操作，但不支持可变 remove()等操作
  5.  使用迭代器进行遍历的速度很快，并且不会与其他线程发生冲突。在构造迭代器时，迭代器依赖于不变的数组快照
首先来看一下构造函数，如下所示：
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. private volatile transient Object[] array;  
  2.   
  3. final Object[] getArray() {  
  4.     return array;  
  5. }  
  6. final void setArray(Object[] a) {  
  7.     array = a;  
  8. }  
  9. // -----开始构造函数----------------------------  
  10. public CopyOnWriteArrayList() {  
  11.     setArray(new Object[0]);  
  12. }  
  13. public CopyOnWriteArrayList(Collection<? extends E> c) {  
  14.     Object[] elements = c.toArray();  
  15.     // c.toArray might (incorrectly) not return Object[] (see 6260652)  
  16.     if (elements.getClass() != Object[].class)  
  17.         elements = Arrays.copyOf(elements, elements.length, Object[].class);  
  18.     setArray(elements);  
  19. }  
  20. // Creates a list holding a copy of the given array.  
  21. public CopyOnWriteArrayList(E[] toCopyIn) {  
  22.     setArray(Arrays.copyOf(toCopyIn, toCopyIn.length, Object[].class));  
  23. }  
使用一个指向volatile类型的Object数组来保存容器元素。构造函数中都会根据参数值重新生成一个新的数组。

1、添加元素

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public boolean add(E e) {  
  2.        final ReentrantLock lock = this.lock;                       // 获取独占锁  
  3.        lock.lock();  
  4.        try {  
  5.            Object[] elements = getArray();  
  6.            int len = elements.length;  
  7.            Object[] newElements = Arrays.copyOf(elements, len + 1);// 重新生成一个新的数组实例，并将原始数组的元素拷贝到新数组中  
  8.            newElements[len] = e;                                   // 添加新的元素到新数组的末尾  
  9.            setArray(newElements);                                  // 更新底层数组  
  10.            return true;  
  11.        } finally {  
  12.            lock.unlock();  
  13.        }  
  14.    }  

有两点必须清楚：

 第一，在”添加操作“开始前，获取独占锁(lock)，若此时有需要线程要获取锁，则必须等待；在操作完毕后，释放独占锁(lock)，此时其它线程才能获取锁。通过独占锁，来防止多线程同时修改数据！

 第二，操作完毕时，会通过setArray()来更新volatile数组。对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写入；这样，每次添加元素之后，其它线程都能看到新添加的元素。


2、获取元素

[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public E get(int index) {  
  2.     return get(getArray(), index);  
  3. }  
  4.   
  5. private E get(Object[] a, int index) {  
  6.     return (E) a[index];  
  7. }  
将底层volatile数组指定索引处的元素返回即可。


3、删除元素


以remove(int index)为例，来对“CopyOnWriteArrayList的删除操作”进行说明。下面是remove(int index)的代码：
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public E remove(int index) {  
  2.     final ReentrantLock lock = this.lock;  
  3.     lock.lock();  
  4.     try {  
  5.         Object[] elements = getArray();  
  6.         int len = elements.length;  
  7.         E oldValue = get(elements, index); // 获取volatile数组中指定索引处的元素值  
  8.         int numMoved = len - index - 1;  
  9.         if (numMoved == 0) // 如果被删除的是最后一个元素，则直接通过Arrays.copyOf()进行处理，而不需要新建数组  
  10.             setArray(Arrays.copyOf(elements, len - 1));  
  11.         else {  
  12.             Object[] newElements = new Object[len - 1];  
  13.             System.arraycopy(elements, 0, newElements, 0, index);    // 拷贝删除元素前半部分数据到新数组中  
  14.             System.arraycopy(elements, index + 1, newElements, index, numMoved);// 拷贝删除元素后半部分数据到新数组中  
  15.             setArray(newElements); // 更新volatile数组  
  16.         }  
  17.         return oldValue;  
  18.     } finally {  
  19.         lock.unlock();  
  20.     }  
  21. }  



4、遍历元素


[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. public Iterator<E> iterator() {  
  2.     return new COWIterator<E>(getArray(), 0);  
  3. }  
  4. public ListIterator<E> listIterator() {  
  5.     return new COWIterator<E>(getArray(), 0);  
  6. }  
  7. public ListIterator<E> listIterator(final int index) {  
  8.     Object[] elements = getArray();  
  9.     int len = elements.length;  
  10.     if (index<0 || index>len)  
  11.         throw new IndexOutOfBoundsException("Index: "+index);  
  12.   
  13.     return new COWIterator<E>(elements, index);  
  14. }  
  15.   
  16. private static class COWIterator<E> implements ListIterator<E> {  
  17.     private final Object[] snapshot; // 保存数组的快照，是一个不可变的对象  
  18.     private int cursor;  
  19.   
  20.     private COWIterator(Object[] elements, int initialCursor) {  
  21.         cursor = initialCursor;  
  22.         snapshot = elements;  
  23.     }  
  24.   
  25.     public boolean hasNext() {  
  26.         return cursor < snapshot.length;  
  27.     }  
  28.   
  29.     public boolean hasPrevious() {  
  30.         return cursor > 0;  
  31.     }  
  32.   
  33.     @SuppressWarnings("unchecked")  
  34.     public E next() {  
  35.         if (! hasNext())  
  36.             throw new NoSuchElementException();  
  37.         return (E) snapshot[cursor++];  
  38.     }  
  39.   
  40.     @SuppressWarnings("unchecked")  
  41.     public E previous() {  
  42.         if (! hasPrevious())  
  43.             throw new NoSuchElementException();  
  44.         return (E) snapshot[--cursor];  
  45.     }  
  46.   
  47.     public int nextIndex() {  
  48.         return cursor;  
  49.     }  
  50.   
  51.     public int previousIndex() {  
  52.         return cursor-1;  
  53.     }  
  54.     public void remove() {  
  55.         throw new UnsupportedOperationException();  
  56.     }  
  57.     public void set(E e) {  
  58.         throw new UnsupportedOperationException();  
  59.     }  
  60.     public void add(E e) {  
  61.         throw new UnsupportedOperationException();  
  62.     }  
  63. }  
如上容器的迭代器中会保存一个不可变的Object数组对象，那么在进行遍历这个对象时就不需要再进一步的同步。在每次修改时，都会创建并重新发布一个新的窗口副本，从而实现了可变性。如上迭代器代码中保留了一个指向volatile数组的引用，由于不会被修改，因此多个线程可以同时对它进行迭代，而不会彼此干扰或与修改容器的线程相互干扰。
与之前的ArrayList实现相比，CopyOnWriteArrayList返回迭代器不会抛出ConcurrentModificationException异常，即它不是fail-fast机制的！




转载自http://blog.csdn.net/mazhimazh/




0 0
竞拍源码 竞拍源码
原创粉丝点击
热门IT博客
中文分词算法中文分词算法
机器人炒股宝软件机器人炒股宝软件
休闲西装 知乎
紫鸟数据魔方怎么样
火星时代vr知乎
cron Linux
ubuntu怎么安装搜狗
电脑版淘宝怎么看直播
粤城电器淘宝店怎么样
山西知满天教育怎么样
进销存软件系统设计
沈阳seo关键词排名
linux重命名文件命令
php class 静态方法
怎么禁止下载软件
linux dracut
sql count函数
知之者不如好之者的好
云计算架构师月薪
钢琴谱大全软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 梅兰芳大剧院 阿娇错失梅兰芳 梅葆玖气死梅兰芳 阿娇演梅兰芳 原版梅兰芳梨花颂 梅兰芳梨花颂原唱 梅兰芳梨花颂 梅兰芳阿娇 梅兰芳蓄须 梅兰芳纪念馆 梅兰芳的故事 梅兰芳的简介 陈凯歌梅兰芳 梅兰芳故事 梅兰芳公园旅游 梅兰芳妻子 梅兰芳简介和故事 梅兰芳大剧院场地 梅兰芳大剧院订票 梅兰芳代表作 梅兰芳京剧 梅兰芳大剧院 茶馆 梅兰芳演员表 梅兰芳的子女 梅兰芳有多少钱 梅兰芳有几个妻子 牡丹亭 梅兰芳 梅兰芳影片 梅兰芳大剧场地址 关于梅兰芳的资料 幼年梅兰芳 梅兰芳影评 梅兰芳子女 梅兰芳的妻子 梅兰芳儿子 梅兰芳图片 梅兰芳怎么死的 梅兰芳是 梅兰芳原名 梅兰芳蓄须教学设计 梅兰芳大剧院演出票

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里