[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6},"actionData","errors","routes/blog-tag",{"_7":8,"_9":10},"tag",{"_31":89,"_73":90,"_35":91},"articles",{"_11":12,"_13":14,"_15":16,"_17":16,"_18":19,"_20":21,"_22":23,"_24":23,"_25":16,"_26":27},"content",[30],"pageable",{"_28":21,"_29":19},"totalElements",1,"totalPages","size",10,"number",0,"first",true,"last","numberOfElements","empty",false,"page_number","page_size",{"_31":32,"_33":34,"_35":36,"_37":38,"_11":39,"_40":-5,"_41":23,"_42":27,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":52,"_54":55,"_56":57,"_58":59,"_60":52,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":72},"id",116,"title","Copy-on-Write Collections","slug","java-collections-part-20-copy-on-write","excerpt","Understand copy-on-write semantics for read-heavy concurrent scenarios, snapshot iterators preventing ConcurrentModificationException, and event listener patterns.","# Java Collections Compendium Part 20: Copy-On-Write Collections\n\nMaster Copy-On-Write semantics for read-heavy concurrent scenarios. Understand when CopyOnWriteArrayList and CopyOnWriteArraySet shine, their memory implications, and why they're perfect for event listener patterns.\n\n## 📋 At a Glance\n\n| Aspect | Details |\n|--------|---------|\n| **Topic** | CopyOnWriteArrayList, CopyOnWriteArraySet, snapshot iterators |\n| **Complexity** | Intermediate |\n| **Prerequisites** | Part 18 (ConcurrentHashMap), basic concurrency |\n| **Time to Master** | 2-3 hours |\n| **Interview Frequency** | Medium-High (listener patterns, read-heavy scenarios) |\n\n## 🎯 What You'll Learn\n\nAfter completing this article, you will be able to:\n\n1. Understand Copy-On-Write semantics and memory implications\n2. Use CopyOnWriteArrayList for event listener management\n3. Know when COW collections are appropriate (and when not)\n4. Implement thread-safe observer patterns without locks\n5. Avoid common COW pitfalls like memory spikes\n\n---\n\n## Production Story: The Event Listener That Never Threw\n\n### The Incident\n\nOur UI framework was plagued by `ConcurrentModificationException` in the event dispatch system. Adding or removing listeners during event dispatch caused random crashes:\n\n```java\n// EventDispatcher.java - The problematic code\npublic class EventDispatcher {\n private List listeners = new ArrayList<>();\n\n public void addListener(EventListener listener) {\n listeners.add(listener);\n }\n\n public void removeListener(EventListener listener) {\n listeners.remove(listener);\n }\n\n public void fireEvent(Event event) {\n for (EventListener listener : listeners) { // 💥 CME risk!\n listener.onEvent(event);\n // Listener might call addListener or removeListener!\n }\n }\n}\n```\n\n### Why It Failed\n\n```text\nThread 1 (dispatch): Thread 2 (modify):\n──────────────────── ──────────────────\nfor (listener : listeners)\n └─ listener.onEvent()\n └─ handler code addListener(newListener)\n │ └─ modifies listeners\n └─ continues iteration 💥 ConcurrentModificationException!\n```\n\n### The CopyOnWriteArrayList Solution\n\n```java\n// EventDispatcher.java - The robust solution\npublic class EventDispatcher {\n private final List listeners = new CopyOnWriteArrayList<>();\n\n public void addListener(EventListener listener) {\n listeners.add(listener); // Creates new array copy\n }\n\n public void removeListener(EventListener listener) {\n listeners.remove(listener); // Creates new array copy\n }\n\n public void fireEvent(Event event) {\n for (EventListener listener : listeners) { // ✅ Never throws CME!\n listener.onEvent(event);\n // Safe even if listener modifies the list\n }\n }\n}\n```\n\n### How It Works\n\n```text\nInitial state:\nlisteners → [A, B, C]\n\nDuring fireEvent() iteration on [A, B, C]:\n├─ Iterator sees snapshot: [A, B, C]\n│\n├─ addListener(D) called:\n│ └─ Creates new array: [A, B, C, D]\n│ └─ listeners → [A, B, C, D]\n│ └─ Iterator still sees: [A, B, C] (old array)\n│\n├─ removeListener(B) called:\n│ └─ Creates new array: [A, C, D]\n│ └─ listeners → [A, C, D]\n│ └─ Iterator still sees: [A, B, C] (old array)\n│\n└─ Iteration completes normally on snapshot\n\nNext fireEvent() will see: [A, C, D]\n```\n\n### Performance Trade-off\n\n```java\n// Write operations are expensive - full copy!\n// For 1000 listeners:\n// - add(): Copies all 1000 elements → O(n)\n// - remove(): Copies all 1000 elements → O(n)\n// - get()/iteration: No copy, just reads → O(1)\n\n// Perfect for: Few writes, many reads\n// Bad for: Frequent writes\n```\n\n---\n\n## Mental Model: The Immutable Photograph\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ COPY-ON-WRITE: THE PHOTOGRAPH │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ Regular ArrayList = Live Video Feed │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ 📹 Viewers see changes IMMEDIATELY │ │\n│ │ If someone walks in front → everyone sees it │ │\n│ │ If camera moves → everyone sees it │ │\n│ │ Risk: Viewers might see partial/inconsistent state │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n│ CopyOnWriteArrayList = Photographs │\n│ ┌─────────────────────────────────────────────────────────────┐ │\n│ │ 📷 Each iterator gets a PHOTOGRAPH (snapshot) │ │\n│ │ Viewer A: Looking at Photo v1 [A, B, C] │ │\n│ │ Viewer B: Looking at Photo v1 [A, B, C] │ │\n│ │ │ │\n│ │ *Someone adds D* │ │\n│ │ New Photo v2: [A, B, C, D] │ │\n│ │ │ │\n│ │ Viewer A: Still looking at Photo v1 [A, B, C] │ │\n│ │ Viewer B: Still looking at Photo v1 [A, B, C] │ │\n│ │ New viewers: Get Photo v2 [A, B, C, D] │ │\n│ │ │ │\n│ │ Cost: Taking a new photo (copy) for every change │ │\n│ └─────────────────────────────────────────────────────────────┘ │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n### Interactive Visualization\n\nWatch how CopyOnWrite handles concurrent readers and writers:\n\n```visualizer-copyonwrite\ncontrols: true\n```\n\n---\n\n## Deep Dive: CopyOnWriteArrayList Internals\n\n### Core Structure\n\n```java\npublic class CopyOnWriteArrayList implements List {\n // Volatile ensures visibility across threads\n private transient volatile Object[] array;\n\n final Object[] getArray() {\n return array;\n }\n\n final void setArray(Object[] a) {\n array = a;\n }\n}\n```\n\n### Write Operations (Always Copy)\n\n```java\n// Simplified add() implementation\npublic boolean add(E e) {\n synchronized (lock) { // Lock for write operations\n Object[] elements = getArray();\n int len = elements.length;\n\n // Create new array with +1 capacity\n Object[] newElements = Arrays.copyOf(elements, len + 1);\n newElements[len] = e;\n\n setArray(newElements); // Atomic reference swap\n return true;\n }\n}\n\n// Simplified remove() implementation\npublic E remove(int index) {\n synchronized (lock) {\n Object[] elements = getArray();\n E oldValue = elementAt(elements, index);\n\n int numMoved = elements.length - index - 1;\n Object[] newElements;\n if (numMoved == 0) {\n newElements = Arrays.copyOf(elements, elements.length - 1);\n } else {\n newElements = new Object[elements.length - 1];\n System.arraycopy(elements, 0, newElements, 0, index);\n System.arraycopy(elements, index + 1, newElements, index, numMoved);\n }\n\n setArray(newElements);\n return oldValue;\n }\n}\n```\n\n### Read Operations (No Copy, No Lock)\n\n```java\n// get() is lock-free!\npublic E get(int index) {\n return elementAt(getArray(), index); // Just read volatile array\n}\n\n// size() is lock-free\npublic int size() {\n return getArray().length;\n}\n\n// Iterator captures snapshot\npublic Iterator iterator() {\n return new COWIterator(getArray(), 0); // Snapshot!\n}\n\nstatic final class COWIterator implements ListIterator {\n private final Object[] snapshot; // Captured at creation\n private int cursor;\n\n COWIterator(Object[] elements, int initialCursor) {\n cursor = initialCursor;\n snapshot = elements; // Just reference, no copy\n }\n\n public boolean hasNext() {\n return cursor < snapshot.length;\n }\n\n public E next() {\n return (E) snapshot[cursor++];\n }\n\n // remove() throws UnsupportedOperationException!\n // Can't modify snapshot\n}\n```\n\n---\n\n## Deep Dive: CopyOnWriteArraySet\n\n### Implementation\n\n```java\n// CopyOnWriteArraySet is just CopyOnWriteArrayList with uniqueness check\npublic class CopyOnWriteArraySet extends AbstractSet {\n private final CopyOnWriteArrayList al;\n\n public CopyOnWriteArraySet() {\n al = new CopyOnWriteArrayList<>();\n }\n\n public boolean add(E e) {\n return al.addIfAbsent(e); // Only adds if not present\n }\n\n public boolean contains(Object o) {\n return al.contains(o); // O(n) linear search!\n }\n}\n```\n\n### addIfAbsent Pattern\n\n```java\n// CopyOnWriteArrayList.addIfAbsent\npublic boolean addIfAbsent(E e) {\n Object[] snapshot = getArray();\n // First check without lock\n if (indexOf(e, snapshot, 0, snapshot.length) >= 0) {\n return false; // Already present\n }\n\n synchronized (lock) {\n Object[] current = getArray();\n if (current != snapshot) {\n // Array changed, re-check\n if (indexOf(e, current, 0, current.length) >= 0) {\n return false;\n }\n }\n // Not present, add it\n Object[] newElements = Arrays.copyOf(current, current.length + 1);\n newElements[current.length] = e;\n setArray(newElements);\n return true;\n }\n}\n```\n\n---\n\n## Deep Dive: When to Use COW Collections\n\n### Perfect Use Cases\n\n```java\n// ✅ Event listeners (few listeners, many events)\nCopyOnWriteArrayList listeners = new CopyOnWriteArrayList<>();\n// Add/remove rare, fire events often\n\n// ✅ Configuration cache (rarely updated)\nCopyOnWriteArrayList configs = new CopyOnWriteArrayList<>();\n// Load once, read many times\n\n// ✅ Observer pattern\nCopyOnWriteArraySet observers = new CopyOnWriteArraySet<>();\n// Subscribe/unsubscribe rare, notify often\n\n// ✅ Small whitelist/blacklist\nCopyOnWriteArraySet allowedHosts = new CopyOnWriteArraySet<>();\n// Few entries, frequent contains checks\n```\n\n### Bad Use Cases\n\n```java\n// ❌ Large lists with frequent writes\nCopyOnWriteArrayList logs = new CopyOnWriteArrayList<>();\nfor (int i = 0; i < 1_000_000; i++) {\n logs.add(entry); // 1M copies, each bigger than last!\n}\n// Use: ConcurrentLinkedQueue or ArrayList with external sync\n\n// ❌ Contains-heavy operations on large sets\nCopyOnWriteArraySet largeSet = new CopyOnWriteArraySet<>();\n// 10,000 elements\nfor (String s : queries) {\n if (largeSet.contains(s)) { ... } // O(n) each time!\n}\n// Use: ConcurrentHashMap.newKeySet()\n\n// ❌ Frequent batch updates\nfor (int i = 0; i < 1000; i++) {\n cowList.add(items.get(i)); // 1000 copies!\n}\n// Use: addAll() for single copy, or different collection\n```\n\n### Decision Matrix\n\n```text\n┌─────────────────────────────────────────────────────────────────────┐\n│ COW vs ALTERNATIVES │\n├─────────────────────────────────────────────────────────────────────┤\n│ │\n│ Scenario Best Choice │\n│ ────────────────────────── ───────────────────────────────────── │\n│ Few writes, many reads CopyOnWriteArrayList ✅ │\n│ Many writes, many reads ConcurrentLinkedQueue │\n│ Set with fast contains ConcurrentHashMap.newKeySet() │\n│ Ordered, frequent updates Collections.synchronizedList() │\n│ Blocking producer-consumer BlockingQueue implementations │\n│ │\n│ Size Guidelines: │\n│ < 100 elements: COW usually fine │\n│ 100-1000: Consider access patterns carefully │\n│ > 1000: Probably not COW │\n│ │\n└─────────────────────────────────────────────────────────────────────┘\n```\n\n---\n\n## Deep Dive: Common Patterns\n\n### Pattern 1: Event Dispatcher\n\n```java\npublic class TypeSafeEventDispatcher {\n private final CopyOnWriteArrayList> listeners =\n new CopyOnWriteArrayList<>();\n\n public void addListener(Consumer listener) {\n listeners.add(Objects.requireNonNull(listener));\n }\n\n public void removeListener(Consumer listener) {\n listeners.remove(listener);\n }\n\n public void dispatch(E event) {\n // Safe iteration even if listeners modify the list\n for (Consumer listener : listeners) {\n try {\n listener.accept(event);\n } catch (Exception e) {\n // Log and continue - don't let one listener break others\n logger.error(\"Listener error\", e);\n }\n }\n }\n\n public int listenerCount() {\n return listeners.size();\n }\n}\n```\n\n### Pattern 2: Configuration Registry\n\n```java\npublic class ConfigRegistry {\n private final CopyOnWriteArrayList entries =\n new CopyOnWriteArrayList<>();\n\n public void register(String key, Object value) {\n // Remove old entry if exists\n entries.removeIf(e -> e.key.equals(key));\n entries.add(new ConfigEntry(key, value));\n }\n\n public Optional

Copyonwritearrayset

Copy-on-Write Collections