脚本之家 服务器常用软件
微信 投稿 交流社区 在线工具

Java源码解析CopyOnWriteArrayList的讲解

 更新时间:2019年01月08日 14:10:34   作者:李灿辉   我要评论

今天小编就为大家分享一篇关于Java源码解析CopyOnWriteArrayList的讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧

本文基于jdk1.8进行分析。

ArrayList和HashMap是我们经常使用的集合,它们不是线程安全的。我们一般都知道HashMap的线程安全版本为ConcurrentHashMap,那么ArrayList有没有类似的线程安全的版本呢?还真有,它就是CopyOnWriteArrayList。

CopyOnWrite这个短语,还有一个专门的称谓COW. COW不仅仅是java实现集合框架时专用的机制,它在计算机中被广泛使用。

首先看一下什么是CopyOnWriteArrayList,它的类前面的javadoc注释很长,我们只截取最前面的一小段。如下。它的介绍中说到,CopyOnWriteArrayList是ArrayList的一个线程安全的变种,在CopyOnWriteArrayList中,所有改变操作(add,set等)都是通过给array做一个新的拷贝来实现的。通常来看,这花费的代价太大了,但是,当读取list的线程数量远远多于写list的线程数量时,这种方法依然比别的实现方式更高效。

/**
 * A thread-safe variant of {@link java.util.ArrayList} in which all mutative
 * operations ({@code add}, {@code set}, and so on) are implemented by
 * making a fresh copy of the underlying array.
 * <p>This is ordinarily too costly, but may be <em>more</em> efficient
 * than alternatives when traversal operations vastly outnumber
 * mutations, and is useful when you cannot or don't want to
 * synchronize traversals, yet need to preclude interference among
 * concurrent threads. The "snapshot" style iterator method uses a
 * reference to the state of the array at the point that the iterator
 * was created. This array never changes during the lifetime of the
 * iterator, so interference is impossible and the iterator is
 * guaranteed not to throw {@code ConcurrentModificationException}.
 * The iterator will not reflect additions, removals, or changes to
 * the list since the iterator was created. Element-changing
 * operations on iterators themselves ({@code remove}, {@code set}, and
 * {@code add}) are not supported. These methods throw
 * {@code UnsupportedOperationException}.
 **/

下面看一下成员变量。只有2个,一个是基本数据结构array,用于保存数据,一个是可重入锁,它用于写操作的同步。

  /** The lock protecting all mutators **/
  final transient ReentrantLock lock = new ReentrantLock();
  /** The array, accessed only via getArray/setArray. **/
  private transient volatile Object[] array;

下面看一下主要方法。get方法如下。get方法没有什么特殊之处,不加锁,直接读取即可。

  /**
   * {@inheritDoc}
   * @throws IndexOutOfBoundsException {@inheritDoc}
   **/
  public E get(int index) {
    return get(getArray(), index);
  }
  /**
   * Gets the array. Non-private so as to also be accessible
   * from CopyOnWriteArraySet class.
   **/
  final Object[] getArray() {
    return array;
  }
  @SuppressWarnings("unchecked")
  private E get(Object[] a, int index) {
    return (E) a[index];
  }

下面看一下add。add方法先加锁,然后,把原array拷贝到一个新的数组中,并把待添加的元素加入到新数组,最后,再把新数组赋值给原数组。这里可以看到,add操作并不是直接在原数组上操作,而是把整个数据进行了拷贝,才操作的,最后把新数组赋值回去。

  /**
   * Appends the specified element to the end of this list.
   * @param e element to be appended to this list
   * @return {@code 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();
    }
  }
  /**
   * Sets the array.
   **/
  final void setArray(Object[] a) {
    array = a;
  }

这里,思考一个问题。线程1正在遍历list,此时,线程2对线程进行了写入,那么,线程1可以遍历到线程2写入的数据吗?

首先明确一点,这个场景不会抛出任何异常,程序会安静的执行完成。是否能到读到线程2写入的数据,取决于遍历方式和线程2的写入时机及位置。

首先看遍历方式,我们2中方式遍历list,foreach和get(i)的方式。foreach的底层实现是迭代器,所以迭代器就不单独作为一种遍历方式了。首先看一下通过for循环get(i)的方式。这种遍历方式下,能否读取到线程2写入的数据,取决了线程2的写入时机和位置。如果线程1已经遍历到第5个元素了,那么如果线程2在第5个后面进行写入,那么线程1就可以读取到线程2的写入。

public class MyClass {
  static List<String> list = new CopyOnWriteArrayList<>();
  public static void main(String[] args){
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("e");
    list.add("f");
    list.add("g");
    list.add("h");
    //启动线程1,遍历数据
    new Thread(()->{
      try{
        for(int i = 0; i < list.size();i ++){
          System.out.println(list.get(i));
          Thread.sleep(1000);
        }
      }catch (Exception e){
        e.printStackTrace();
      }
    }).start();
    try{
      //主线程作为线程2,等待2s
      Thread.sleep(2000);
    }catch (Exception e){
      e.printStackTrace();
    }
    //主线程作为线程2,在位置4写入数据,即,在遍历位置之后写入数据
    list.add(4,"n");
  }
}

上述程序的运行结果如下,是可以遍历到n的。

a
b
c
d
n
e
f
g
h

如果线程2在第5个位置前面写入,那么线程1就读取不到线程2的写入。同时,还会带来一个副作用,就是某个元素会被读取2次。代码如下:

public class MyClass {
  static List<String> list = new CopyOnWriteArrayList<>();
  public static void main(String[] args){
    list.add("a");
    list.add("b");
    list.add("c");
    list.add("d");
    list.add("e");
    list.add("f");
    list.add("g");
    list.add("h");
    //启动线程1,遍历数据
    new Thread(()->{
      try{
        for(int i = 0; i < list.size();i ++){
          System.out.println(list.get(i));
          Thread.sleep(1000);
        }
      }catch (Exception e){
        e.printStackTrace();
      }
    }).start();
    try{
      //主线程作为线程2,等待2s
      Thread.sleep(2000);
    }catch (Exception e){
      e.printStackTrace();
    }
    //主线程作为线程2,在位置1写入数据,即,在遍历位置之后写入数据
    list.add(1,"n");
  }
}

上述代码的运行结果如下,其中,b被遍历了2次。

a
b
b
c
d
e
f
g
h

那么,采用foreach方式遍历呢?答案是无论线程2写入时机如何,线程2都无法读取到线程2的写入。原因在于CopyOnWriteArrayList在创建迭代器时,取了当前时刻数组的快照。并且,add操作只会影响原数组,影响不到迭代器中的快照。

  public Iterator<E> iterator() {
    return new COWIterator<E>(getArray(), 0);
  }
  private COWIterator(Object[] elements, int initialCursor) {
      cursor = initialCursor;
      snapshot = elements;
  }

了解清楚了遍历方式和写入时机对是否能够读取到写入的影响,我们在使用CopyOnWriteArrayList时就可以根据实际业务场景的需求,选择合适的实现方式了。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对脚本之家的支持。如果你想了解更多相关内容请查看下面相关链接

  • java
  • copyonwritearraylist

相关文章

  • java接入创蓝253短信验证码的实例讲解

    java接入创蓝253短信验证码的实例讲解

    下面小编就为大家分享一篇java接入创蓝253短信验证码的实例讲解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
    2018-01-01
  • Java内存区域与内存溢出异常详解

    Java内存区域与内存溢出异常详解

    这篇文章主要介绍了Java内存区域与内存溢出异常详解的相关资料,需要的朋友可以参考下
    2017-03-03
  • 浅谈Java编程中string的理解与运用

    浅谈Java编程中string的理解与运用

    这篇文章主要介绍了浅谈Java编程中string的理解与运用,还是比较不错的,这里分享给大家,供需要的朋友参考。
    2017-11-11
  • Java多线程之死锁的出现和解决方法

    Java多线程之死锁的出现和解决方法

    本篇文章主要介绍了Java多线程之死锁的出现和解决方法,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-10-10
  • Java建造者设计模式详解

    Java建造者设计模式详解

    这篇文章主要为大家详细介绍了Java建造者设计模式,对建造者设计模式进行分析理解,感兴趣的小伙伴们可以参考一下
    2016-02-02
  • 详解Springboot对多线程的支持

    详解Springboot对多线程的支持

    Spring是通过任务执行器(TaskExecutor)来实现多线程和并发编程,使用ThreadPoolTaskExecutor来创建一个基于线城池的TaskExecutor。这篇文章给大家介绍Springboot对多线程的支持,感兴趣的朋友一起看看吧
    2018-07-07
  • java存储以及java对象创建的流程(详解)

    java存储以及java对象创建的流程(详解)

    下面小编就为大家带来一篇java存储以及java对象创建的流程(详解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2017-05-05
  • Java的绘图模式使用浅析

    Java的绘图模式使用浅析

    这篇文章主要介绍了Java的绘图模式使用浅析,以一个小例子大概列举了XOR模式下能干的一些事情,需要的朋友可以参考下
    2015-10-10
  • spring中ioc是什么

    spring中ioc是什么

    IoC是一种让服务消费者不直接依赖于服务提供者的组件设计方式,是一种减少类与类之间依赖的设计原则。下面通过本文给大家分享spring中ioc的概念,感兴趣的朋友一起看看吧
    2017-09-09
  • Hibernate批量处理海量数据的方法

    Hibernate批量处理海量数据的方法

    这篇文章主要介绍了Hibernate批量处理海量数据的方法,较为详细的分析了Hibernate批量处理海量数据的原理与相关实现技巧,需要的朋友可以参考下
    2016-03-03

最新评论