Understanding CopyOnWrite (COW) Concept and Its Implementation in Java

CopyOnWrite (COW) is a concurrency strategy where a write operation first creates a copy of the target object, modifies the copy, and then atomically switches the reference so that readers continue to see the original data until the new version is published.

Key points of the COW approach:

Optimized for read‑many/write‑few workloads, maximizing read throughput.

Provides eventual consistency: readers see the old state until the write completes.

To make new data visible promptly, a volatile variable is used.

Writes must be exclusive; they are protected by a lock.

The Java CopyOnWriteArrayList implements this idea with a ReentrantLock for write operations and a volatile array reference that readers access without locking.

/** The lock protecting all mutators */
final transient ReentrantLock lock = new ReentrantLock();

/** The array, accessed only via getArray/setArray. */
private transient volatile Object[] array;

/**
 * Appends the specified element to the end of this list.
 * @param e element to be appended to this list
 * @return true (as specified by 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();
    }
}

The volatile modifier forces each thread to read the latest value of the array reference from main memory, ensuring visibility of updates across threads.

The transient keyword indicates that the field should not be serialized, which is relevant when objects are transferred or persisted.

Drawbacks of CopyOnWrite containers:

Memory overhead: Each write creates a new copy of the underlying array, potentially doubling memory usage during updates, which can trigger frequent Full GC in large‑object scenarios.

Consistency limitation: Only eventual consistency is guaranteed; readers may not see the most recent write immediately, making COW unsuitable for real‑time data requirements.