Что знаешь для реализации happens before

Happens-Before в Java

Happens-Before — это гарантия Java Memory Model, которая определяет порядок видимости операций памяти между потоками. Если операция A happens-before операции B, то все эффекты операции A будут видны потоку, выполняющему операцию B.

Основные концепции

1. Видимость памяти — гарантия видимости изменений между потоками
2. Переупорядочение инструкций — JVM может переупорядочивать инструкции для оптимизации
3. Синхронизация — механизм обеспечения happens-before отношений
4. Barriers — особые инструкции для обеспечения порядка
5. Race conditions — проблемы при отсутствии happens-before

Правила Happens-Before

1. Monitor Lock (synchronized)

private int value = 0;
private final Object lock = new Object();

// Поток 1
synchronized(lock) {
    value = 42;  // Happens-before unlock
}

// Поток 2
synchronized(lock) {
    int x = value;  // Видит value = 42
}

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

private volatile int counter = 0;

// Поток 1
counter = 10;  // Write happens-before all subsequent reads

// Поток 2
int x = counter;  // Видит 10

3. Happens-Before с volatile

public class VolatileExample {
    private volatile boolean flag = false;
    private int data = 0;
    
    public void writer() {
        data = 42;           // Обычная запись
        flag = true;         // Volatile запись
        // Все предыдущие операции видны после flag = true
    }
    
    public void reader() {
        if (flag) {          // Volatile чтение
            System.out.println(data);  // Видит 42
        }
    }
}

4. Thread.start() and Thread.join()

public class ThreadStartJoin {
    private int value = 0;
    
    public void example() {
        Thread t = new Thread(() -> {
            // Видит value = 42
            System.out.println(value);
        });
        
        value = 42;
        t.start();  // start() happens-before работу потока
        
        try {
            t.join();  // join() happens-before продолжение
        } catch (InterruptedException e) {}
    }
}

5. Transitive (транзитивность)

if (A happens-before B && B happens-before C)
    then A happens-before C

AtomicInteger и атомарные операции

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicExample {
    private AtomicInteger counter = new AtomicInteger(0);
    private int data = 0;
    
    public void writer() {
        data = 42;
        counter.set(1);  // Atomic set happens-before reads
    }
    
    public void reader() {
        if (counter.get() == 1) {  // Видит data = 42
            System.out.println(data);
        }
    }
}

Lock/Unlock из java.util.concurrent.locks

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockExample {
    private Lock lock = new ReentrantLock();
    private int value = 0;
    
    public void writer() {
        lock.lock();
        try {
            value = 42;
        } finally {
            lock.unlock();  // unlock happens-before next lock
        }
    }
    
    public void reader() {
        lock.lock();
        try {
            System.out.println(value);  // Видит 42
        } finally {
            lock.unlock();
        }
    }
}

Happens-Before правила (полный список)

Пример Race Condition (БЕЗ happens-before)

public class RaceCondition {
    private int counter = 0;  // НЕ volatile!
    
    public void increment() {
        counter++;  // НЕ потокобезопасно
    }
    
    public int get() {
        return counter;  // Может видеть старое значение
    }
}

// Проблема: счётчик может потерять обновления
// Решение: volatile или synchronized

Правильная реализация

public class ThreadSafe {
    // Вариант 1: volatile
    private volatile int counter = 0;
    
    // Вариант 2: synchronized
    public synchronized void increment() {
        counter++;
    }
    
    // Вариант 3: AtomicInteger
    private AtomicInteger atomicCounter = new AtomicInteger(0);
    public void incrementAtomic() {
        atomicCounter.incrementAndGet();
    }
}

Реальный пример: Double-Checked Locking

public class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized(Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// volatile гарантирует happens-before при инициализации

Заключение

Happens-Before — это фундаментальный концепт многопоточного программирования в Java. Понимание этого гарантирует написание потокобезопасного кода. Основные инструменты: synchronized, volatile, AtomicInteger, Lock. Всегда используй эти механизмы для синхронизации между потоками.