Кратко — проблемы: состояние гонки (race condition), потеря инкрементов и отсутствие гарантии видимости между потоками. Пояснение и решения ниже.
1) В чём именно проблема
- Операция `c++` не атомарна: это чтение, изменение и запись. При двух потоках возможна потеря обновления: оба читают $0$, оба записывают $1$ → итог $1$ вместо $2$.
Пример последовательности: поток A читает $0$, поток B читает $0$, A пишет $1$, B пишет $1$ → ожидали $2$.
- Отсутствие синхронизации даёт проблемы видимости: один поток может не увидеть обновление, сделанное другим (чтение даст «устаревшее» значение).
- Также без соответствующих барьеров компилятор/CPU может делать переупорядочивания, нарушая ожидаемые отношения.
2) Какие гарантии нужны
- Атомарность операции инкремента: инкремент должен выполняться как неделимая операция.
- Гарантия видимости / happens-before: после завершения инкремента другой поток, читающий счётчик, должен увидеть обновлённое значение.
- Последовательность при высоком содержании (опционально) — требования к пропускной способности.
3) Как безопасно реализовать счётчик (варианты)
- Синхронизация:
public class Counter {
private int c = 0;
public synchronized void inc() { c++; }
public synchronized int get() { return c; }
}
Гарантирует атомарность и видимость (мониторный lock создаёт happens-before).
- AtomicInteger:
import java.util.concurrent.atomic.AtomicInteger;
public class Counter {
private final AtomicInteger c = new AtomicInteger(0);
public void inc() { c.incrementAndGet(); } // атомарно
public int get() { return c.get(); }
}
AtomicInteger даёт атомарные операции и необходимые memory‑barriers без явного lock; хорошо в большинстве случаев.
- LongAdder (при высокой конкуренции):
import java.util.concurrent.atomic.LongAdder;
public class Counter {
private final LongAdder c = new LongAdder();
public void inc() { c.increment(); }
public long get() { return c.sum(); }
}
LongAdder даёт лучшую пропускную способность при многих потоках, но internal sharding и сборка суммы.
- Явные блокировки:
private final ReentrantLock lock = new ReentrantLock();
public void inc() { lock.lock(); try { c++; } finally { lock.unlock(); } }
- Что НЕ работает:
- Объявление `private volatile int c;` не делает `c++` атомарным — потеря обновлений всё ещё возможна.
4) Рекомендация
- Для простого счётчика используйте `AtomicInteger` (или `LongAdder` при высокой конкуренции). Если требуется групповая согласованность с другими состояниями — используйте `synchronized` или `ReentrantLock`.
Если нужно, могу показать минимальные рабочие примеры или объяснить отличие `AtomicInteger.incrementAndGet()` и `compareAndSet()` — скажите.