CopyOnWriteArrayList in Java

CopyOnWriteArrayList is a thread-safe, high-performance alternative to ArrayList, designed specifically for read-heavy and write-rare use cases. It belongs to the java.util.concurrent package.

The key idea is simple:

Every write operation creates a new copy of the internal array, ensuring that readers always see a consistent and safe snapshot without locks.

What is CopyOnWriteArrayList?

CopyOnWriteArrayList is a special list where:

• All writes (add, remove, set) create a new array copy
• Reads are extremely fast
• No locking is required for reading
• Iterators are fail-safe (never throw ConcurrentModificationException)
• Perfect for concurrent read-mostly applications

Why “Copy On Write”? (Internal Working)

When you do:

list.add("A");

Internally, it performs:

1. Creates a new array
2. Copies old elements into the new array
3. Adds the new element
4. Replaces the old array reference

• Safe in multi-threaded environments
• Ultra-fast reads
• Write operations are expensive (copying large arrays takes time)

Features of CopyOnWriteArrayList

When Should You Use CopyOnWriteArrayList?

Use it when:

• Reads are very frequent
• Writes are very rare
• You need fast, consistent iteration
• You want to avoid ConcurrentModificationException
• Many threads are reading concurrently

Real-world use cases:

• Caching data
• Application configuration values
• Observer / listener lists
• Messaging subscribers
• Read-only or rarely updated datasets

When NOT to Use It

Avoid CopyOnWriteArrayList when:

• Frequent writes (copying on each write is slow)
• Large lists (copy cost becomes huge)
• Real-time or performance-critical write operations

Basic Example

import java.util.concurrent.CopyOnWriteArrayList;

public class Example {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

        list.add("A");
        list.add("B");

        for (String s : list) {
            System.out.println(s);
        }
    }
}

Fail-Safe Iterator Example

CopyOnWriteArrayList iterates over a snapshot, so modifications during iteration don’t cause errors.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
list.add("One");
list.add("Two");

for (String s : list) {
    list.add("New"); // Safe — No ConcurrentModificationException
    System.out.println(s);
}

Output:

One
Two

("New" will not appear during this iteration because iterator uses a snapshot.)

Important Methods

Difference Between CopyOnWriteArrayList vs ArrayList vs Vector

Points to Remember

• Thread-safe, optimized for concurrent reads
• Writes are expensive because it copies the array
• Iterators are fail-safe
• Ideal for read-mostly applications
• Part of java.util.concurrent