[Java] Java源码解析CopyOnWriteArrayList的讲解

/**
 * 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}.
 **/

/** the lock protecting all mutators **/
final transient reentrantlock lock = new reentrantlock();
/** the array, accessed only via getarray/setarray. **/
private transient volatile object[] array;

/**
 * {@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];
}

/**
 * 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;
}

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");
  }
}

a
b
c
d
n
e
f
g
h

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");
  }
}

a
b
b
c
d
e
f
g
h

public iterator<e> iterator() {
  return new cowiterator<e>(getarray(), 0);
}
private cowiterator(object[] elements, int initialcursor) {
  cursor = initialcursor;
  snapshot = elements;
}