Introduction to COW mechanism and related classes

The content of this article is an introduction to the COW mechanism and related classes. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.

COW mechanism has related classes

Vector and SynchronizedList

We know that ArrayList is used to replace Vector, and Vector is a thread-safe container. Because it adds the synchronized keyword to almost every method declaration to make the container safe. If you use Collections.synchronizedList(new ArrayList()) to make ArrayList thread-safe, almost every method will add the synchronized keyword, but it is not added at the declaration of the method, but at the method internal.

Under multi-threaded for loop iteration of Vector or SynchronizedList, an array subscript error exception will occur when performing delete and get operations.

After JDK5, Java recommends using for-each (iterator) to traverse our collection. The advantage is that it is simple and the boundary value of the array index is only calculated once. If you use for-each (iterator) to do the above operation, a ConcurrentModificationException will be thrown.

If we want to perfectly solve the problem mentioned above, we can add a lock before traversing:

I have to add a lock when traversing the container. Isn’t this going to be too slow? . It's indeed quite slow. Because the locking granularity is too large.

CopyOnWriteArrayList is a replacement for synchronous List, and CopyOnWriteArraySet is a replacement for synchronous Set.

Hashtable and Vector have large locking granularity (use synchronized directly at the method declaration) ConcurrentHashMap and CopyOnWriteArrayList have small locking granularity (use various methods to achieve thread safety, for example, we know that ConcurrentHashMap uses cas lock , volatile and other methods to achieve thread safety..) The thread-safe container under JUC will not throw ConcurrentModificationException during traversal. So generally speaking, we will use the thread-safe container provided to us under the JUC package instead of using the old A generation of thread-safe containers.

CopyOnWriteArrayList implementation principle

CopyOnWriteArrayList is a thread-safe container (relative to ArrayList), and the bottom layer is implemented by copying the array. CopyOnWriteArrayList will not throw ConcurrentModificationException when traversing, and there is no need to lock additional elements during traversal. The element can be null

/** 可重入锁对象 */
    final transient ReentrantLock lock = new ReentrantLock();
    /** CopyOnWriteArrayList底层由数组实现，volatile修饰 */
    private transient volatile Object[] array;

    final Object[] getArray() {
        return array;
    }
    final void setArray(Object[] a) {
        array = a;
    }
    // 初始化CopyOnWriteArrayList相当于初始化数组
    public CopyOnWriteArrayList() {
        setArray(new Object[0]);
    }

The bottom layer of CopyOnWriteArrayList is an array, and the locking is done by ReentrantLock.

We can know from the code: lock when add(), set(), remove(), and copy a new array, the addition operation is completed on the new array, and the array points to the new array , finally unlocked. When modifying, a new array is copied, the modification operation is completed in the new array, and finally the new array is pointed to by the array variable. Locked for writing, not locked for reading

Disadvantages of CopyOnWriteArrayList

Memory usage: If CopyOnWriteArrayList often adds, deletes, and changes the data in it, and often executes add(), set(), and remove() , which consumes more memory.

Because we know that each addition, deletion, and modification operation such as add(), set(), and remove() must copy an array.

Data consistency: The CopyOnWrite container can only guarantee the final consistency of the data, but cannot guarantee the real-time consistency of the data.

It can also be seen from the above example, for example, thread A is iterating the data of the CopyOnWriteArrayList container. Thread B modified the data in the CopyOnWriteArrayList part during the iteration gap of thread A (setArray() has been called). But thread A iterates out the original data.

The above is the detailed content of Introduction to COW mechanism and related classes. For more information, please follow other related articles on the PHP Chinese website!