Как можно реализовать безопасную многопоточную разработку?

Ответ

Безопасная многопоточная разработка требует правильной синхронизации и избежания race conditions.

1. Synchronized методы

public class Counter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;
    }
    
    public synchronized int getCount() {
        return count;
    }
}

2. AtomicInteger (рекомендуется)

public class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
    
    public int getCount() {
        return count.get();
    }
}

Атомарные операции не требуют блокировки и работают быстрее.

3. ConcurrentHashMap для коллекций

Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);
map.putIfAbsent("key2", 2);
Integer value = map.computeIfAbsent("key3", k -> 3);

Использует segmented locking для высокой параллельности.

4. ReentrantLock для сложных сценариев

public class SafeBuffer {
    private final ReentrantLock lock = new ReentrantLock();
    private Queue queue = new LinkedList();
    
    public void add(Object item) {
        lock.lock();
        try {
            queue.offer(item);
        } finally {
            lock.unlock();
        }
    }
}

5. ReadWriteLock для read-heavy данных

public class Cache {
    private final ReadWriteLock lock = new ReentrantReadWriteLock();
    private Map data = new HashMap();
    
    public Object get(String key) {
        lock.readLock().lock();
        try {
            return data.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }
}

Множество потоков могут читать одновременно.

6. CopyOnWriteArrayList

List<String> list = new CopyOnWriteArrayList<>();
list.add("item");
for (String item : list) {
    System.out.println(item);
}

Хорошо для часто читаемых, редко изменяемых коллекций.

7. Immutable объекты

public final class User {
    private final String name;
    private final int age;
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() { return name; }
    public int getAge() { return age; }
}

Полностью потокобезопасны.

8. Volatile для флагов

public class Worker {
    private volatile boolean running = true;
    
    public void stop() {
        running = false;
    }
}

Обеспечивает видимость изменений между потоками.

9. CountDownLatch для синхронизации

CountDownLatch latch = new CountDownLatch(3);
for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        task();
        latch.countDown();
    }).start();
}
latch.await();
System.out.println("Done");

10. Semaphore для ограничения доступа

Semaphore sem = new Semaphore(5);
sem.acquire();
try {
    useResource();
} finally {
    sem.release();
}

Лучшие практики

1. Избегайте shared mutable state
2. Используйте immutable объекты где возможно
3. Используйте concurrent коллекции вместо synchronized
4. Используйте AtomicXXX для простых значений
5. Не держите блокировку долго
6. Тестируйте многопоточность
7. Документируйте thread-safety
8. Используйте volatile для флагов
9. Избегайте nested locks
10. Используйте ThreadLocal аккуратно

В моём опыте обработка данных в 50+ потоках требует правильного выбора инструментов синхронизации для максимальной производительности.