你知道Java中的CopyOnWriteArrayList吗？

1
2
3
public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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();
    }
}

1
2
3
4
public E get(int index) {
    return get(getArray(), index);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public E set(int index, E element) {
   //加锁
   final ReentrantLock lock = this.lock;
   lock.lock();
   try {
       //获取原来数组
       Object[] elements = getArray();
       // 通过索引获取原来的地址
       E oldValue = get(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
           //为了确保 voliatile 的语义，所以尽管写操作没有改变数据，还是调用set方法
           setArray(elements);
       }
       return oldValue;
   } finally {
       lock.unlock();
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public E remove(int index) {  
    final ReentrantLock lock = this.lock;  
    lock.lock();  
    try {  
        Object[] elements = getArray();  
        int len = elements.length;  
        E oldValue = get(elements, index);  
        int numMoved = len - index - 1;  
        if (numMoved == 0)  
            setArray(Arrays.copyOf(elements, len - 1));  
        else {  
            Object[] newElements = new Object[len - 1];  
            System.arraycopy(elements, 0, newElements, 0, index);  
            System.arraycopy(elements, index + 1, newElements, index,  
                             numMoved);  
            setArray(newElements);  
        }  
        return oldValue;  
    } finally {  
        lock.unlock();  
    }  
}  

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code remove}
 *         is not supported by this iterator.
 */
public void remove() {
    throw new UnsupportedOperationException();
}

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code set}
 *         is not supported by this iterator.
 */
public void set(E e) {
    throw new UnsupportedOperationException();
}

/**
 * Not supported. Always throws UnsupportedOperationException.
 * @throws UnsupportedOperationException always; {@code add}
 *         is not supported by this iterator.
 */
public void add(E e) {
    throw new UnsupportedOperationException();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
 
Iterator<String> iterator = list.iterator();
while(iterator.hasNext()) {
    String next = iterator.next();
       // 这句会报错的⚠️
    iterator.remove();
}
 
Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.concurrent.CopyOnWriteArrayList$COWIterator.remove(CopyOnWriteArrayList.java:1178)