// Упрощенная концептуальная реализация
public static <T> List<T> synchronizedList(List<T> list) {
    return (list instanceof RandomAccess ?
        new SynchronizedRandomAccessList<>(list) :
        new SynchronizedList<>(list));
}

static class SynchronizedList<E> implements List<E> {
    final List<E> list;   // Оборачиваемый список
    final Object mutex;   // Объект для синхронизации
    
    SynchronizedList(List<E> list) {
        this.list = list;
        this.mutex = this; // По умолчанию синхронизируемся на обертке
    }
    
    public E get(int index) {
        synchronized (mutex) { return list.get(index); }
    }
    
    public void add(int index, E element) {
        synchronized (mutex) { list.add(index, element); }
    }
    
    // Все методы синхронизированы аналогично
}

// ОПАСНО: неатомарная составная операция
List<String> syncList = Collections.synchronizedList(new ArrayList<>());

if (!syncList.contains("item")) {    // Операция 1
    syncList.add("item");            // Операция 2
}
// Между проверкой и добавлением другой поток может добавить элемент

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// ОПАСНО: ConcurrentModificationException все еще возможен
for (String item : syncList) {
    // Другой поток может модифицировать список
    syncList.remove("someItem"); // Из другого потока
}

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

// Безопасная итерация
synchronized (syncList) {
    Iterator<String> it = syncList.iterator();
    while (it.hasNext()) {
        String item = it.next();
        process(item);
    }
}

// Концептуальная структура с Java 8
public class ConcurrentHashMap<K,V> {
    volatile Node<K,V>[] table;
    
    static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        volatile V val;
        volatile Node<K,V> next;
    }
    
    static final class TreeNode<K,V> extends Node<K,V> {
        TreeNode<K,V> parent;
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;
        boolean red;
    }
}

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();

// Поток 1
map.put("key", 42); // Запись с memory barrier

// Путок 2
Integer value = map.get("key"); // Чтение с happens-before гарантиями
// Гарантированно увидит 42, если нет перезаписи

// Атомарные операции
map.putIfAbsent(key, value);    // Вставить если отсутствует
map.replace(key, oldValue, newValue); // Заменить если совпадает
map.compute(key, (k, v) -> v == null ? 1 : v + 1); // Атомарное вычисление

ConcurrentHashMap<String, Long> wordCounts = new ConcurrentHashMap<>();

// Параллельный forEach
wordCounts.forEach(1, // Параллелизм
    (key, value) -> System.out.println(key + ":" + value));

// Поиск
String result = wordCounts.search(1, 
    (key, value) -> value > 1000 ? key : null);

// Свертка
long total = wordCounts.reduceValues(1, Long::sum);

ConcurrentHashMap<String, Data> map = new ConcurrentHashMap<>(
    16,      // initial capacity
    0.75f,   // load factor
    8        // concurrency level (оценочное количество потоков)
);

ConcurrentHashMap<String, String> map = new ConcurrentHashMap<>();

// Приближенный размер (O(1), но может быть неточным)
int approximateSize = map.size();

// Более точный (но дорогой) подсчет
int exactSize = map.mappingCount(); // Java 8+

// Проверка пустоты (эффективная)
boolean isEmpty = map.isEmpty();

public class CopyOnWriteArrayList<E> {
    private transient volatile Object[] array;
    
    final Object[] getArray() {
        return array;
    }
    
    final void setArray(Object[] a) {
        array = a;
    }
}

public class EventPublisher {
    private final CopyOnWriteArrayList<EventListener> listeners =
        new CopyOnWriteArrayList<>();
    
    public void addListener(EventListener listener) {
        listeners.add(listener); // Безопасно даже во время уведомлений
    }
    
    public void publish(Event event) {
        for (EventListener listener : listeners) {
            // Итерация по snapshot - безопасна
            listener.onEvent(event);
        }
    }
}

public class ConfigurationCache {
    private volatile CopyOnWriteArrayList<Config> cache;
    
    public ConfigurationCache() {
        cache = new CopyOnWriteArrayList<>();
    }
    
    public void refresh() {
        List<Config> newConfigs = loadConfigs();
        // Атомарная замена всего кэша
        cache = new CopyOnWriteArrayList<>(newConfigs);
    }
    
    public List<Config> getConfigs() {
        return cache; // Безопасное чтение
    }
}

// Для частых модификаций
List<String> frequentWrites = Collections.synchronizedList(new ArrayList<>());

// Для mixed workloads
ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<>();

// Для сценариев с преобладанием чтения
List<String> readMostly = new CopyOnWriteArrayList<>();

// Внутренний механизм ArrayList
protected transient int modCount = 0;

// В итераторе
int expectedModCount = modCount;

void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}

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

for (String item : list) {          // Создается итератор
    if (item.equals("B")) {
        list.remove(item);           // modCount++ → исключение!
    }
}

// Поток 1
for (String item : sharedList) {
    process(item);                   // Итерация
}

// Поток 2
sharedList.add("new");              // ConcurrentModificationException в потоке 1

public class UnsafeCache {
    private Map<String, Data> cache = new HashMap<>();
    
    public Data get(String key) {
        Data data = cache.get(key);
        if (data == null) {
            data = loadData(key);         // Дорогая операция
            cache.put(key, data);         // Race condition!
        }
        return data;                      // Может вернуть null
    }
}

public class BrokenSingleton {
    private static Data instance;
    
    public static Data getInstance() {
        if (instance == null) {                    // Первая проверка (без синхронизации)
            synchronized (BrokenSingleton.class) {
                if (instance == null) {            // Вторая проверка
                    instance = new Data();         // Небезопасная публикация!
                }
            }
        }
        return instance;                           // Может вернуть частично инициализированный объект
    }
}

// ConcurrentHashMap: запрещает null
ConcurrentHashMap<String, String> chm = new ConcurrentHashMap<>();
chm.put("key", null);               // NullPointerException

// CopyOnWriteArrayList: разрешает null
CopyOnWriteArrayList<String> cowal = new CopyOnWriteArrayList<>();
cowal.add(null);                    // Допустимо

// Collections.synchronizedList: зависит от оборачиваемой коллекции
List<String> syncList = Collections.synchronizedList(new ArrayList<>());
syncList.add(null);                 // Допустимо для ArrayList

public class Counter {
    private int count;
    
    public void increment() {
        count++; // Неатомарная операция: read-modify-write
    }
}

// Два потока вызывают increment() 1000 раз каждый
// Ожидаемый результат: 2000
// Фактический результат: что угодно между 1000 и 2000

public class VisibilityProblem {
    private boolean ready = false;
    private int value;
    
    // Поток 1
    public void writer() {
        value = 42;
        ready = true; // Без happens-before!
    }
    
    // Путок 2
    public void reader() {
        if (ready) {
            System.out.println(value); // Может увидеть 0 вместо 42!
        }
    }
}

// Классический deadlock с synchronizedList
List<String> list1 = Collections.synchronizedList(new ArrayList<>());
List<String> list2 = Collections.synchronizedList(new ArrayList<>());

// Поток 1
synchronized (list1) {
    synchronized (list2) {  // Ждет list2
        // Критическая секция
    }
}

// Путок 2 (обратный порядок)
synchronized (list2) {
    synchronized (list1) {  // Ждет list1 → DEADLOCK!
        // Критическая секция
    }
}

public class LivelockExample {
    private final ConcurrentHashMap<String, Boolean> locks = 
        new ConcurrentHashMap<>();
    
    public void process(String key) {
        // Бесконечные попытки захвата "локера"
        while (!locks.putIfAbsent(key, true)) {
            Thread.yield(); // Livelock: постоянно уступаем, но не прогрессируем
        }
        
        try {
            // Работа с ресурсом
        } finally {
            locks.remove(key);
        }
    }
}

// Поток, постоянно читающий
synchronized (sharedList) {
    // Долгая операция чтения
    processAllElements(sharedList);
}

// Другие потоки не могут получить доступ для записи
// → Starvation писателей

import java.util.concurrent.*;

public class Task301225 {
    public static void main(String[] args) {
        ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
        map.put("a", 1);
        
        Integer result = map.computeIfAbsent("b", k -> {
            map.put("b", 2);
            return map.get("b");
        });
        
        System.out.println(result);
        System.out.println(map.get("b"));
    }
}