Какие знаешь техники для безопасной многопоточной разработки?

Техники безопасной многопоточной разработки

Многопоточность в Java требует осторожного подхода, так как неправильное использование может привести к дедлокам, race conditions и потере данных. Вот основные техники для безопасной работы:

1. Синхронизация и Locks

synchronized — самый простой механизм:

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

ReentrantLock предоставляет больше контроля:

import java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
    private int count = 0;
    private final ReentrantLock lock = new ReentrantLock();
    
    public void increment() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
}

2. Volatile переменные

volatile гарантирует видимость изменений между потоками:

public class Flag {
    private volatile boolean stop = false;
    
    public void stopWork() {
        stop = true;  // видно всем потокам
    }
}

3. Immutable объекты

Неизменяемые объекты потокобезопасны от природы:

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

4. Thread-safe коллекции

Используй Collections.synchronizedList() или CopyOnWriteArrayList:

import java.util.concurrent.CopyOnWriteArrayList;

List<String> safeList = new CopyOnWriteArrayList<>();
safeList.add("item");

Для более сложных случаев используй ConcurrentHashMap:

import java.util.concurrent.ConcurrentHashMap;

ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("key", 1);

5. Atomic переменные

AtomicInteger и другие atomic классы безопасны без блокировок:

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);
    
    public void increment() {
        count.incrementAndGet();
    }
}

6. ThreadLocal переменные

Для переменных, уникальных для каждого потока:

public class UserContext {
    private static final ThreadLocal<User> userContext = new ThreadLocal<>();
    
    public static void setUser(User user) {
        userContext.set(user);
    }
    
    public static User getUser() {
        return userContext.get();
    }
}

7. Executor Framework

Делегируй управление потоками ExecutorService:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.submit(() -> {
    // Безопасно: управление потоками берёт на себя фреймворк
});
executor.shutdown();

8. Правильное завершение потоков

Никогда не используй stop(), используй флаги:

public class Worker implements Runnable {
    private volatile boolean running = true;
    
    public void run() {
        while (running) {
            // работа
        }
    }
    
    public void stop() {
        running = false;
    }
}

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

• Минимизируй время, когда lock удерживается
• Избегай вложенных блокировок (риск дедлока)
• Предпочитай immutable объекты где возможно
• Используй higher-level построения вместо низкоуровневых lock'ов
• Тестируй многопоточный код с инструментами как JUnit, ThreadSanitizer

Потокобезопасность — это критическая навык для production приложений.