Какие плюсы и минусы CopyOnWriteArrayList?

Плюсы и минусы CopyOnWriteArrayList

CopyOnWriteArrayList — это потокобезопасная реализация интерфейса List из пакета java.util.concurrent, которая оптимизирована для сценариев с преимущественно частыми операциями чтения и редкими операциями записи.

Что такое CopyOnWriteArrayList?

Это список, который создаёт копию внутреннего массива при каждой операции модификации (добавление, удаление, замена элемента). При чтении потокам не требуется захватывать блокировки, что обеспечивает высокую производительность для read-heavy сценариев.

// Пример использования
public class CopyOnWriteExample {
    public static void main(String[] args) {
        CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
        
        list.add("item1");
        list.add("item2");
        list.add("item3");
        
        // Множество потоков могут читать одновременно без блокировок
        new Thread(() -> {
            for (String item : list) {
                System.out.println("Thread1: " + item);
            }
        }).start();
        
        new Thread(() -> {
            for (String item : list) {
                System.out.println("Thread2: " + item);
            }
        }).start();
        
        // Операция записи создаст копию массива
        list.remove("item2");
    }
}

ПЛЮСЫ CopyOnWriteArrayList

1. Отсутствие блокировок при чтении

Огромный плюс: операции чтения (get, iterate) не требуют синхронизации и не блокируют друг друга.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// Множество потоков могут читать одновременно
for (int i = 0; i < 10; i++) {
    new Thread(() -> {
        // Никаких блокировок, очень быстро
        String item = list.get(0);
        System.out.println("Read: " + item);
    }).start();
}

Сравнение с Collections.synchronizedList:

// Collections.synchronizedList требует блокировки даже для чтения
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// При get(), iterator и других операциях захватывается блокировка

// CopyOnWriteArrayList — чтение без блокировок
CopyOnWriteArrayList<String> cowList = new CopyOnWriteArrayList<>();
// При get(), iterator — блокировок нет

2. Безопасная итерация

Этот список обеспечивает безопасную итерацию без ConcurrentModificationException, даже если другой поток модифицирует список во время итерации.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(Arrays.asList(
    "A", "B", "C", "D", "E"
));

// Поток 1: читаем список
new Thread(() -> {
    for (String item : list) {
        System.out.println("Reading: " + item);
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {}
    }
}).start();

// Поток 2: модифицируем список одновременно
new Thread(() -> {
    try {
        Thread.sleep(50);
        list.remove(0);  // Удаляем элемент
        list.add("F");   // Добавляем новый
    } catch (Exception e) {}
}).start();

// CopyOnWriteArrayList не выбросит ConcurrentModificationException
// В отличие от обычного ArrayList

С обычным ArrayList:

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));
new Thread(() -> {
    for (String item : list) {  // ConcurrentModificationException!
        System.out.println(item);
    }
}).start();

new Thread(() -> list.remove(0)).start();

3. Снимок консистентности (Consistency Snapshot)

Каждый iterator получает снимок данных на момент создания iterator'а.

CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>(Arrays.asList(1, 2, 3));

// Iterator зафиксирует состояние [1, 2, 3]
Iterator<Integer> iterator = list.iterator();

// Даже если мы добавим элементы
list.add(4);
list.add(5);

// Iterator всё ещё видит [1, 2, 3]
while (iterator.hasNext()) {
    System.out.println(iterator.next());  // Выведет 1, 2, 3 (не 1,2,3,4,5)
}

4. Минимальная блокировка

Блокировка требуется только для операций записи, и она очень короткая.

// Примерная реализация (упрощённо)
public class CopyOnWriteArrayList<E> {
    private volatile E[] data;
    private final Object lock = new Object();
    
    public E get(int index) {
        return data[index];  // БЕЗ синхронизации!
    }
    
    public boolean add(E element) {
        synchronized (lock) {  // Синхронизация ТОЛЬКО для write
            E[] newData = new E[data.length + 1];
            System.arraycopy(data, 0, newData, 0, data.length);
            newData[data.length] = element;
            data = newData;
        }
        return true;
    }
}

5. Хорошо для Event Listeners

Отлично подходит для listener'ов и observer'ов, где читаются чаще, чем пишутся.

public class EventManager {
    private CopyOnWriteArrayList<EventListener> listeners = new CopyOnWriteArrayList<>();
    
    public void addListener(EventListener listener) {
        listeners.add(listener);
    }
    
    public void removeListener(EventListener listener) {
        listeners.remove(listener);
    }
    
    public void fireEvent(Event event) {
        // Читаем listener'ы в loop без блокировок
        for (EventListener listener : listeners) {
            listener.onEvent(event);
        }
    }
}

МИНУСЫ CopyOnWriteArrayList

1. Высокая стоимость операций записи (критичный минус)

Главный недостаток: каждое изменение требует копирования всего массива в память.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// Для каждого add() будет скопирован весь массив!
for (int i = 0; i < 100000; i++) {
    list.add("item" + i);  // Копирование: O(n) операция
}

Пример производительности:

CopyOnWriteArrayList<Integer> cow = new CopyOnWriteArrayList<>();
ArrayList<Integer> regular = new ArrayList<>();

// Добавление 1000 элементов
long startCow = System.nanoTime();
for (int i = 0; i < 1000; i++) {
    cow.add(i);
}
long cowTime = System.nanoTime() - startCow;

long startReg = System.nanoTime();
for (int i = 0; i < 1000; i++) {
    regular.add(i);
}
long regTime = System.nanoTime() - startReg;

System.out.println("CopyOnWriteArrayList: " + cowTime / 1_000_000 + "ms");
System.out.println("ArrayList: " + regTime / 1_000_000 + "ms");
// Результат: CopyOnWriteArrayList в 10-100 раз медленнее!

2. Большое потребление памяти

В худшем случае может быть в памяти несколько копий массива одновременно, если один поток читает старую версию, а другой пишет.

CopyOnWriteArrayList<byte[]> list = new CopyOnWriteArrayList<>();

// Добавим крупные объекты
for (int i = 0; i < 100; i++) {
    byte[] largeByte = new byte[1024 * 1024];  // 1MB
    list.add(largeByte);
    // Итого 100MB в памяти
}

// Теперь одновременная запись
new Thread(() -> list.add(new byte[1024 * 1024])).start();
// Может быть в памяти две копии по 100MB одновременно = 200MB+

3. Не подходит для write-heavy сценариев

// ПЛОХО: список с частыми обновлениями
CopyOnWriteArrayList<String> cache = new CopyOnWriteArrayList<>();

ExecutorService executor = Executors.newFixedThreadPool(10);
for (int i = 0; i < 100000; i++) {
    final int index = i;
    executor.submit(() -> {
        // Каждое изменение = копирование всего массива!
        cache.set(index % 1000, "value" + index);
    });
}
executor.shutdown();
// Ужасная производительность!

Для такого случая лучше:

// Вариант 1: ConcurrentHashMap если нужен ассоциативный массив
ConcurrentHashMap<Integer, String> cache = new ConcurrentHashMap<>();
for (int i = 0; i < 100000; i++) {
    final int index = i;
    executor.submit(() -> cache.put(index % 1000, "value" + index));
}

// Вариант 2: Collections.synchronizedList для write-heavy
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
// Хотя это не лучший выбор, но лучше чем CopyOnWriteArrayList для write-heavy

4. Старые значения видны iterator'ом

Это может быть неожиданным поведением в некоторых сценариях.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>(Arrays.asList("A", "B", "C"));

Iterator<String> iterator = list.iterator();

// Добавляем новый элемент
list.add("D");
list.add("E");

// Iterator всё ещё видит [A, B, C]
while (iterator.hasNext()) {
    System.out.println(iterator.next());  // A, B, C (не видит D, E)
}

// Новый iterator видит [A, B, C, D, E]
for (String item : list) {
    System.out.println(item);  // A, B, C, D, E
}

Это может привести к странному поведению в логике, где ожидается видеть последние данные.

5. Пиковая задержка при записи

Операция записи может привести к заметной задержке (pause), если список большой.

CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();

// Добавим миллионы элементов
for (int i = 0; i < 1_000_000; i++) {
    list.add("item" + i);
}

// Теперь одна операция записи может вызвать заметную паузу
long start = System.nanoTime();
list.add("new item");  // Копирует 1 млн элементов = может быть 10-100мс pauzа!
long time = (System.nanoTime() - start) / 1_000_000;
System.out.println("Write time: " + time + "ms");

Таблица сравнения с альтернативами

Когда использовать CopyOnWriteArrayList

ДА, использовать если:

• Список читается очень часто, а пишется редко (ratio 100:1)
• Нужна безопасная итерация без ConcurrentModificationException
• Listener'ы, observer'ы, event handlers
• Конфигурация, которая меняется редко

// ПРАВИЛЬНО: listener'ы которые редко меняются, часто вызываются
public class EventBus {
    private CopyOnWriteArrayList<EventListener> listeners = new CopyOnWriteArrayList<>();
    
    public void registerListener(EventListener listener) {
        listeners.add(listener);  // Редко
    }
    
    public void publishEvent(Event event) {
        // Часто в цикле
        for (EventListener listener : listeners) {
            listener.onEvent(event);
        }
    }
}

НЕТ, не использовать если:

• Список часто модифицируется (добавления, удаления)
• Требуется высокая производительность при записи
• Список может быть очень большим

// НЕПРАВИЛЬНО: частые обновления
CopyOnWriteArrayList<String> cache = new CopyOnWriteArrayList<>();
for (int i = 0; i < 100000; i++) {
    cache.set(i % 100, "value" + i);  // Копирование 100 элементов каждый раз!
}

// ПРАВИЛЬНО: используй ConcurrentHashMap для такого
ConcurrentHashMap<Integer, String> cache = new ConcurrentHashMap<>();
for (int i = 0; i < 100000; i++) {
    cache.put(i % 100, "value" + i);  // Быстро
}

Заключение

CopyOnWriteArrayList — это специализированный список для сценариев с преимущественно операциями чтения. Его главное преимущество — отсутствие блокировок при чтении, что обеспечивает высокую производительность для read-heavy нагрузки. Однако его критический недостаток — высокая стоимость операций записи из-за копирования всего массива.

Используй его только когда уверен, что список читается намного чаще, чем пишется. Для иных сценариев рассмотри ConcurrentHashMap, ArrayList или Collections.synchronizedList.