Java Copy On Write

What is CopyOnWriteArrayList in Java - Example Tutorial
CopyOnWriteArrayList is a concurrent Collection class introduced in Java 5 Concurrency API along with its popular cousinConcurrentHashMap in Java. 
its a thread-safe collection and it achieves its thread-safety in a slightly different way than Vector or other thread-safe collection class. As name suggest CopyOnWriteArrayList creates copy of underlying ArrayList with every mutation operation e.g. add orset. Normally CopyOnWriteArrayList is very expensive because it involves costly Array copy with every write operation but its very efficient if you have a List where Iteration outnumber mutation e.g. you mostly need to iterate the ArrayList and don't modify it too often. Iterator of CopyOnWriteArrayList is fail-safe and doesn't throw ConcurrentModificationExceptioneven if underlying CopyOnWriteArrayList is modified once Iteration begins because Iterator is operating on separate copy of ArrayList. Consequently all the updates made on CopyOnWriteArrayList is not available to Iterator. 

Difference between CopyOnWriteArrayList and ArrayList in Java.

1) First and foremost difference between CopyOnWriteArrayList and ArrayList in Java is that CopyOnWriteArrayList is athread-safe collection while ArrayList is not thread-safe and can not be used in multi-threaded environment.

2) Second difference between ArrayList and CopyOnWriteArrayList is that Iterator of ArrayList is fail-fast and throwConcurrentModificationException once detect any modification in List once iteration begins but Iterator ofCopyOnWriteArrayList is fail-safe and doesn't throw ConcurrentModificationException.

3) Third difference between CopyOnWriteArrayList vs ArrayList is that Iterator of former doesn't support remove operation while Iterator of later supports remove() operation.

add, remove operator is not supported by CopyOnWriteArrayList iterator

    public CopyOnWriteArrayList() {

        setArray(new Object[0]);

    }

    public CopyOnWriteArrayList(Collection<? extends E> c) {

        Object[] elements;

        if (c.getClass() == CopyOnWriteArrayList.class)

            elements = ((CopyOnWriteArrayList<?>)c).getArray();

        else {

            elements = c.toArray();

            // c.toArray might (incorrectly) not return Object[] (see 6260652)

            if (elements.getClass() != Object[].class)

                elements = Arrays.copyOf(elements, elements.length, Object[].class);

        }

        setArray(elements);

    }

    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();

        }

    }

    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

                setArray(elements);

            }

            return oldValue;

        } finally {

            lock.unlock();

        }

    }

    public void add(int index, E element) {

        final ReentrantLock lock = this.lock;

        lock.lock();

        try {

            Object[] elements = getArray();

            int len = elements.length;

            if (index > len || index < 0)

                throw new IndexOutOfBoundsException("Index: "+index+

                                                    ", Size: "+len);

            Object[] newElements;

            int numMoved = len - index;

            if (numMoved == 0)

                newElements = Arrays.copyOf(elements, len + 1);

            else {

                newElements = new Object[len + 1];

                System.arraycopy(elements, 0, newElements, 0, index);

                System.arraycopy(elements, index, newElements, index + 1,

                                 numMoved);

            }

            newElements[index] = element;

            setArray(newElements);

        } finally {

            lock.unlock();

        }

    }

    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();

        }

    }

How to use CopyOnWriteArraySet in Java with Example
CopyOnWriteArraySet is best suited as read-only collection whose size is small enough to copy if some mutative operation happens
CopyOnWriteArraySet is that it is backed byCopyOnWriteArrayList, which means it also share all basic properties ofCopyOnWriteArrayList. Another important thing to remember is that Iterators of this collection class doesn't support remove() operation, trying to remove an element while iterating will result in UnSupportedOperationException. This is done to ensure speed during traversal, traversing this set implementation using Iterator is fast and cannot encounter interference from other threads. Iterators actually rely on unchanging snapshots of the array at the time the iterators were constructed. In short, useCopyOnWriteArraySet if set is small enough to copy on add, set or remove, and main purpose is to read data with occasional updates.
1) CopyOnWriteArraySet is best suited for applications in which set sizes generally stay small, read-only operations vastly outnumber mutative operations, and you need to prevent interference among threads during traversal.

2) Another benefit of CopyOnWriteArraySet is thread-safety, it's a concurrent collection.
3) Mutative operations (add, set, remove, etc.) are expensive since they usually require copying the entire underlying array.

4) Iterators do not support the mutative remove operation.
5) Traversal via iterators is fast and cannot encounter interference from other threads. Iterators rely on unchanging snapshots of the array at the time the iterators were constructed.

public class CopyOnWriteArraySet<E> extends AbstractSet<E>

        implements java.io.Serializable {

    private final CopyOnWriteArrayList<E> al;

    public CopyOnWriteArraySet() {

        al = new CopyOnWriteArrayList<E>();

    }

Copy-on-write optimization for StringBuilder and StringBuffer

The old 1.4 version of StringBuffer had a very nice implementation of a "copy-on-write" (COW), [as have the C++ String and the .NET StringBuilder, I think]. In few words: when the toString() method is called, it doesn't copy the char array to the String, but shares it with the String and marks as "shared" inside; and if there are future call to insert or remove or others in the "immutable" section of the char array, then creates a copy of the array and goes on (so the String keep immutable and the StringB can mute.