// Внутренний механизм 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"));
    }
}