Как управлять Happens-before

# Как управлять Happens-before

Este один из самых сложных и важных аспектов Java Memory Model (JMM). Это определяет, в каком порядке потоки видят изменения других потоков.

Что такое Happens-before

Happens-before — это отношение между двумя действиями (операциями), которое гарантирует, что одно действие произойдёт раньше другого, и его эффекты будут видны.

// Пример БЕЗ happens-before гарантии
public class BadExample {
    private int x = 0;
    
    public void write() {
        x = 1;  // Действие A
    }
    
    public int read() {
        return x;  // Действие B
    }
}

// Thread 1: write() устанавливает x = 1
// Thread 2: read() может вернуть 0 или 1 (непредсказуемо!)

Правила Happens-before в Java

1. Program Order Rule (Порядок внутри потока)

Действия внутри одного потока выполняются в порядке, определённом программой:

public class SingleThread {
    int x = 0;
    int y = 0;
    
    public void method() {
        x = 1;      // Действие 1
        y = 2;      // Действие 2
        int z = x + y;  // Действие 3 ВСЕГДА видит x=1, y=2
    }
}

2. Monitor Lock Rule (synchronized блоки)

Все действия ДО выхода из synchronized блока видны потокам, вошедшим в него позже:

public class SynchronizedExample {
    private int value = 0;
    
    public synchronized void write() {
        value = 1;      // Действие A
    }                   // Unlock — happens-before
    
    public synchronized int read() {
        return value;   // Lock — видит x=1 гарантированно
    }
}

// Thread 1: write()  -> value = 1 -> unlock
// Thread 2: read()   -> lock (видит value = 1)

3. Volatile Semantics

Запись в volatile переменную happens-before чтение этой переменной:

public class VolatileExample {
    private volatile int value = 0;
    
    public void write() {
        int x = 1;
        int y = 2;
        value = x + y;  // Volatile write
    }
    
    public int read() {
        int result = value;  // Volatile read (видит значение из write)
        // ВСЕ операции до volatile write видны здесь
        return result;
    }
}

// Гарантия: все операции ДО volatile write видны ДО volatile read

4. Start Rule

Запуск потока (thread.start()) happens-before действиям в этом потоке:

public class StartRuleExample {
    private int x = 0;
    
    public void mainThread() {
        x = 1;          // Действие A
        thread.start();  // Действие B (happens-before)
    }
    
    public void workerThread() {
        int y = x;  // ГАРАНТИРОВАННО видит x=1
    }
}

5. Join Rule

Все действия в потоке happens-before возврату из thread.join():

Thread thread = new Thread(() -> {
    x = 1;      // Действие в потоке
});

thread.start();
thread.join();  // Ждём завершения

int result = x;  // ГАРАНТИРОВАННО видит x=1

6. Initialization Safety

Zаписи в final поля в конструкторе happens-before использованию объекта другим потоком:

public class ImmutableObject {
    private final int x;
    
    public ImmutableObject(int x) {
        this.x = x;  // Final write в конструкторе
    }
}

// Thread 1: new ImmutableObject(42);
// Thread 2: obj.x  // ГАРАНТИРОВАННО видит 42

7. Double-checked Locking (правильно)

Осторожно с этим паттерном! Правильный способ:

public class Singleton {
    private static volatile Singleton instance;  // VOLATILE!
    
    public static Singleton getInstance() {
        if (instance == null) {  // Первая проверка без блокировки
            synchronized (Singleton.class) {  // Lock
                if (instance == null) {  // Вторая проверка
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// volatile + synchronized = безопасно!

Как управлять Happens-before

Способ 1: synchronized (Monitor Lock Rule)

public class ThreadSafeCounter {
    private int count = 0;
    
    public synchronized void increment() {
        count++;  // Защищено синхронизацией
    }
    
    public synchronized int getCount() {
        return count;  // happens-before increment
    }
}

Способ 2: volatile (для простых случаев)

public class VolatileFlag {
    private volatile boolean flag = false;
    
    public void setFlag() {
        flag = true;  // Volatile write
    }
    
    public boolean isSet() {
        return flag;  // Volatile read
    }
}

Способ 3: ReentrantLock (явная блокировка)

public class LockExample {
    private final Lock lock = new ReentrantLock();
    private int value = 0;
    
    public void write() {
        lock.lock();  // Acquire happens-before
        try {
            value = 1;
        } finally {
            lock.unlock();  // Release happens-before
        }
    }
    
    public int read() {
        lock.lock();  // Видит изменения из write
        try {
            return value;
        } finally {
            lock.unlock();
        }
    }
}

Способ 4: Atomic классы

public class AtomicExample {
    private AtomicInteger counter = new AtomicInteger(0);
    
    public void increment() {
        counter.incrementAndGet();  // Atomic операция
    }
    
    public int getCount() {
        return counter.get();  // Видит incrementAndGet
    }
}

Способ 5: ConcurrentHashMap

public class ConcurrentExample {
    private Map<String, String> map = new ConcurrentHashMap<>();
    
    public void put(String key, String value) {
        map.put(key, value);  // Happens-before для get
    }
    
    public String get(String key) {
        return map.get(key);  // Видит значение из put
    }
}

Практический пример: Правильный singleton

// ПЛОХО: не безопасно для многопоточности
public class BadSingleton {
    private static BadSingleton instance;
    
    public static BadSingleton getInstance() {
        if (instance == null) {
            instance = new BadSingleton();  // Race condition!
        }
        return instance;
    }
}

// ХОРОШО: eager initialization
public class EagerSingleton {
    private static final EagerSingleton instance = new EagerSingleton();
    
    public static EagerSingleton getInstance() {
        return instance;  // Безопасно (Initialization Safety)
    }
}

// ХОРОШО: double-checked locking
public class LazyVolatileSingleton {
    private static volatile LazyVolatileSingleton instance;
    
    public static LazyVolatileSingleton getInstance() {
        if (instance == null) {
            synchronized (LazyVolatileSingleton.class) {
                if (instance == null) {
                    instance = new LazyVolatileSingleton();
                }
            }
        }
        return instance;
    }
}

// ЛУЧШЕ: holder pattern (обеспечивает ленивую инициализацию БЕЗ volatile)
public class HolderSingleton {
    private static class Holder {
        static final HolderSingleton instance = new HolderSingleton();
    }
    
    public static HolderSingleton getInstance() {
        return Holder.instance;  // Class loading гарантирует happens-before
    }
}

Правила для инженера

1. Используйте synchronized для защиты обычного кода
2. Используйте volatile только для простых флагов
3. Используйте Atomic для счётчиков и ссылок
4. Используйте ConcurrentHashMap вместо synchronized HashMap
5. Избегайте volatile на полях объектов (используйте synchronized)
6. Никогда не полагайтесь на порядок без явной синхронизации

Распространённые ошибки

// ❌ ОПАСНО: нет happens-before гарантии
private int x = 0;
public void write() { x = 1; }
public int read() { return x; }

// ✅ ПРАВИЛЬНО
private volatile int x = 0;
public void write() { x = 1; }
public int read() { return x; }

// ✅ ИЛИ
private int x = 0;
public synchronized void write() { x = 1; }
public synchronized int read() { return x; }

Вывод

Happens-before управляет видимостью операций между потоками. Ключевые инструменты:

• synchronized — самый надёжный
• volatile — для флагов
• Atomic — для счётчиков
• Concurrent коллекции — для многопоточных данных
• final — автоматическая безопасность

Знание Java Memory Model критично для написания безопасного многопоточного кода.