Java集合源码学习(8)_List接口的实现_CopyOnWriteArrayList

CopyOnWriteArrayList直接实现了List的接口；没有继承自AbstractList;

1：内部实现的数据结构也是基于数组的；

transient final ReentrantLock lock = new ReentrantLock();//
private volatile transient Object[] array;//存放数据的数组

2：每一个修改性的操作(比如add()、remove()、set())都不是直接操作数据实际存放的array的，都是先copy一份数据在copy的数组上进行操作，然后再设置array为新的修改过后的数组；因此，该类比较适合遍历查询多余修改操作的List，发送在查找阶段的修改不能在已经创建的迭代器中显示

例如，

public E set(int index, E element) {
final ReentrantLock lock = this.lock;//这个锁是不是只能保证同时只有一个线程可以执行set任务？其他的修改性操作呢？
lock.lock();
try {
Object[] elements = getArray();
Object oldValue = elements[index];

if (oldValue != element) {
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len);
newElements[index] = element;
setArray(newElements);
} else {
// Not quite a no-op; ensures volatile write semantics
setArray(elements);
}
return (E) oldValue;
} finally {
lock.unlock();
}
}

3：每一个查找性的操作，都是copy一份当前的array，在copy的数组上进行查找操作，不会受到修改性操作的影响；

public int indexOf(Object o) {
<span style="white-space:pre">	</span>Object[] elements = getArray();
<span style="white-space:pre">	</span>return indexOf(o, elements, 0, elements.length);
}

private static int indexOf(Object o, Object[] elements, int index, int fence) {
if (o == null) {
for (int i = index; i < fence; i++)
if (elements[i] == null)
return i;
} else {
for (int i = index; i < fence; i++)
if (o.equals(elements[i]))
return i;
}
return -1;
}

4：listIterator()返回的是一个COWIterator的实例；不支持remove和add的操作，只能查询；每一次listIterator()都是返回一个新的COWIterator，且查询的数组都是创建迭代器时的array，不受其他修改操作的影响；

private static class COWIterator<E> implements ListIterator<E> {
/** Snapshot of the array **/
private final Object[] snapshot;
/** Index of element to be returned by subsequent call to next. */
private int cursor;

private COWIterator(Object[] elements, int initialCursor) {
cursor = initialCursor;
snapshot = elements;
}

public boolean hasNext() {
return cursor < snapshot.length;
}

public boolean hasPrevious() {
return cursor > 0;
}

public E next() {
if (!hasNext())
throw new NoSuchElementException();
return (E) snapshot[cursor++];
}

public E previous() {
if (!hasPrevious())
throw new NoSuchElementException();
return (E) snapshot[--cursor];
}

public int nextIndex() {
return cursor;
}

public int previousIndex() {
return cursor - 1;
}

public void remove() {
throw new UnsupportedOperationException();
}

public void set(E e) {
throw new UnsupportedOperationException();
}

public void add(E e) {
throw new UnsupportedOperationException();
}
}