Copy-on-Write Collections

📋 Quick Reference

Property	Value
Type	Thread-safe collections via copy-on-write
Read	O(1) - no locking
Write	O(n) - copies entire array
Iteration	Safe, snapshot at iterator creation
Best For	Read-heavy, rare writes, event listeners

One-liner: Thread-safe collections where writes copy the entire backing array - perfect for read-heavy workloads.

🎮 Interactive Visualizer

Watch how Copy-on-Write handles concurrent reads and writes:

CopyOnWriteArrayList
Read: O(1)Write: O(n)
Readers:R1
R2
R3
Writer:W1
1 / 0
Use cases:Event listeners, observers, config that rarely changes
Avoid when:Frequent writes (each write copies entire array)
📋 Copy-on-Write Pattern
Read (get)
O(1)
No lock, no copy
Write (add/set)
O(n)
Full array copy
Best for: Read-heavy, rarely-modified collections • Iterators never throw ConcurrentModificationException
Current Array
Key insight: During writes, old array continues serving readers. No reader ever sees partial state!
Pseudocode
1// CopyOnWriteArrayList
2 
3get(index):  // Lock-free!
4  return array[index]
5 
6add(element):
7  lock.lock()
8  newArray = Arrays.copyOf(array)
9  newArray[len] = element
10  array = newArray  // Atomic swap
11  lock.unlock()
Variables
—
Keyboard Shortcuts
P Play / Pause
[ Step back
] Step forward
R Reset
Speed
Reader
Reader
Writer
Writer
New element
New element
P · [ ] · R
Loading visualizer...

Try these operations:

See multiple readers access simultaneously (no blocking)
Watch a write operation create a new copy
Observe iterators using the old snapshot
Notice: readers never blocked, even during writes

🔧 Key Operations

CopyOnWriteArrayList

JAVA(24 lines)
Code
Loading syntax highlighter...

CopyOnWriteArraySet

JAVA(10 lines)
Code
Loading syntax highlighter...

📊 Complexity Analysis

Operation	CopyOnWriteArrayList	CopyOnWriteArraySet
`get(i)`	O(1)	N/A
`contains`	O(n)	O(n)
`add`	O(n)	O(n)
`remove`	O(n)	O(n)
`iterator()`	O(1)	O(1)
Iteration	O(n)	O(n)

How Copy-on-Write Works

Initial state:
reference → [A, B, C, D]

Write operation (add "E"):
1. Create new array: [A, B, C, D, E]
2. Copy existing elements
3. Add new element
4. Atomically swap reference

reference → [A, B, C, D, E]  (new array)
            [A, B, C, D]     (old array, still used by existing iterators)

Existing iterators continue using old array (snapshot)
New iterators use new array

✅ When to Use Copy-on-Write

Good Use Cases

Event listeners - listener list rarely changes, iterated often
Configuration - read constantly, updated rarely
Observer pattern - notify many observers, add/remove rare
Snapshot iteration - need consistent view during traversal
Read-heavy workloads - writes are 1% or less of operations

Avoid When

Write-heavy - each write copies entire array
Large collections - copy cost too high
Memory constrained - maintains old copies until iterators complete
Need O(1) contains - use ConcurrentHashMap.newKeySet() instead

🔄 Copy-on-Write vs Alternatives

Feature	CopyOnWriteArrayList	synchronizedList	ConcurrentLinkedQueue
Iteration	Safe (snapshot)	Needs external sync	Safe (weakly consistent)
Read performance	Excellent	Good	Good
Write performance	Poor (O(n))	Good (O(1))	Good (O(1))
Memory	Higher (copies)	Normal	Normal
Best for	Read-heavy	Moderate mix	Queue operations

JAVA(8 lines)
Code
Loading syntax highlighter...

🧩 Common Patterns

Event Listener Management

JAVA(20 lines)
Code
Loading syntax highlighter...

Configuration Registry

JAVA(15 lines)
Code
Loading syntax highlighter...

Observer Pattern

JAVA(14 lines)
Code
Loading syntax highlighter...

⚠️ Common Pitfalls

1. Using for Write-Heavy Workloads

JAVA(8 lines)
Code
Loading syntax highlighter...

2. Expecting CopyOnWriteArraySet O(1) Contains

JAVA(6 lines)
Code
Loading syntax highlighter...

3. Large Collections

JAVA(6 lines)
Code
Loading syntax highlighter...

4. Modifying During Iteration

JAVA(16 lines)
Code
Loading syntax highlighter...

🎤 Interview Tips

Q: When would you use CopyOnWriteArrayList?

"

When you have many more reads than writes, especially for things like event listeners or configuration. Writes are expensive (O(n)) but reads are lock-free and iteration is always safe.

Q: How does CopyOnWriteArrayList achieve thread safety?

"

Every mutative operation (add, set, remove) creates a fresh copy of the underlying array. The reference is then atomically swapped. Reads see a consistent snapshot without locking.

Q: Why doesn't iterator support remove()?

"

The iterator works on a snapshot of the array at creation time. The current array may have changed since then, so the iterator can't know which element to remove from the current array.

Q: CopyOnWriteArraySet vs ConcurrentHashMap.newKeySet()?

"

CopyOnWriteArraySet has O(n) contains (linear search) and O(n) writes. ConcurrentHashMap.newKeySet() has O(1) contains and O(1) writes. Use COW only if you need snapshot iteration or very small sets.

Previous: Part 15: BlockingQueue

Next: Part 17: Immutable Collections

Visualizer: CopyOnWrite from @tomaszjarosz/react-visualizers

📋 Quick Reference

🎮 Interactive Visualizer

CopyOnWriteArrayList

🔧 Key Operations

CopyOnWriteArrayList

CopyOnWriteArraySet

📊 Complexity Analysis

How Copy-on-Write Works

✅ When to Use Copy-on-Write

Good Use Cases

Avoid When

🔄 Copy-on-Write vs Alternatives

🧩 Common Patterns

Event Listener Management

Configuration Registry

Observer Pattern

⚠️ Common Pitfalls

1. Using for Write-Heavy Workloads

2. Expecting CopyOnWriteArraySet O(1) Contains

3. Large Collections

4. Modifying During Iteration

🎤 Interview Tips

📚 Series Navigation

Tags:

CopyOnWriteArrayList