Почему Java Memory Model важно при работе с многопоточностью?

Почему Java Memory Model важно при работе с многопоточностью?

Краткий ответ

Java Memory Model (JMM) определяет правила, по которым потоки видят изменения в памяти друг друга. Без этих правил программа с многопоточностью была бы непредсказуемой и опасной.

Проблема: Race Conditions

Пример 1: Видимость изменений

public class VisibilityProblem {
    private boolean flag = false;
    private int value = 0;
    
    // Поток 1
    public void write() {
        value = 42;           // Запись в основную память
        flag = true;          // Запись флага
    }
    
    // Поток 2
    public void read() {
        if (flag) {
            System.out.println(value);  // Может быть 0 или 42?
        }
    }
}

Без JMM поток 2 может не увидеть изменения из потока 1, потому что они могут находиться в кеше CPU потока 1.

Проблема кеширования

// Без синхронизации:
Thread 1 (CPU 1):           Thread 2 (CPU 2):
  Local Cache: flag = ?       Local Cache: flag = ?
  Main Memory: flag = false

Thread 1 пишет: flag = true (в локальный кеш)
Thread 2 читает: flag = false (видит старое значение из памяти)

Что такое Java Memory Model

JMM определяет:

1. Гарантии видимости — когда изменения в одном потоке видны другому
2. Порядок операций — в каком порядке выполняются операции с памятью
3. Happens-Before отношения — последовательность событий между потоками

Happens-Before отношения

Правило 1: synchronized блок

public class SynchronizedExample {
    private int value = 0;
    
    public synchronized void write() {
        value = 42;  // Запись
    }
    
    public synchronized int read() {
        return value;  // Чтение
    }
}

Гарантия JMM:

• Все операции до выхода из synchronized видны после входа в другой synchronized блок

Thread 1: write() {
    value = 42;      // Этот write
}                   // Happens-Before

Thread 2: read() {
    return value;    // Увидит 42
}

Правило 2: volatile переменная

public class VolatileExample {
    private volatile int value = 0;  // volatile!
    
    public void write() {
        value = 42;  // Сразу пишется в основную память
    }
    
    public int read() {
        return value;  // Всегда читает из основной памяти
    }
}

Гарантия volatile:

• Чтение/запись происходит в основной памяти, не в кеше
• Все операции до write() видны после read()

Правило 3: start() потока

public class ThreadStartExample {
    private int value = 0;
    
    public void example() {
        value = 42;
        
        Thread t = new Thread(() -> {
            System.out.println(value);  // Гарантированно увидит 42
        });
        
        t.start();  // Happens-Before
    }
}

Гарантия: Все операции до start() видны в новом потоке.

Правило 4: join() потока

public class ThreadJoinExample {
    private int value = 0;
    
    public void example() throws InterruptedException {
        Thread t = new Thread(() -> {
            value = 42;
        });
        
        t.start();
        t.join();  // Ждем завершения
        
        System.out.println(value);  // Гарантированно 42
    }
}

Гарантия: Все операции в потоке до join() видны после join().

Реальные примеры проблем без JMM

Пример 1: Некорректный double-checked locking

public class BadDoubleCheckLocking {
    private Helper helper = null;
    
    public Helper getHelper() {
        if (helper == null) {  // Проверка 1
            synchronized (this) {
                if (helper == null) {  // Проверка 2
                    helper = new Helper();  // Проблема: если Helper не volatile
                }
            }
        }
        return helper;
    }
}

Проблема: Поток может увидеть частично инициализированный объект Helper.

Правильное решение:

public class CorrectDoubleCheckLocking {
    private volatile Helper helper = null;  // volatile!
    
    public Helper getHelper() {
        if (helper == null) {
            synchronized (this) {
                if (helper == null) {
                    helper = new Helper();
                }
            }
        }
        return helper;
    }
}

Пример 2: Проблема с флагом

// ❌ Неправильно
public class StopFlag {
    private boolean stopRequested = false;
    
    public void run() {
        while (!stopRequested) {
            System.out.println("Running...");
        }
    }
    
    public void stop() {
        stopRequested = true;  // Может не быть видно другому потоку!
    }
}

// ✅ Правильно
public class StopFlagFixed {
    private volatile boolean stopRequested = false;  // volatile!
    
    public void run() {
        while (!stopRequested) {
            System.out.println("Running...");
        }
    }
    
    public void stop() {
        stopRequested = true;  // Сразу видно другому потоку
    }
}

Синхронизация и JMM

public class SynchronizationExample {
    private int x = 0;
    private int y = 0;
    
    public synchronized void writer() {
        x = 1;
        y = 2;
    }
    
    public synchronized void reader() {
        int a = y;
        int b = x;
        System.out.println("x: " + b + ", y: " + a);
    }
}

JMM гарантирует: Если reader() видит y = 2, то он также видит x = 1.

Практические рекомендации

1. Используй synchronized для общих переменных

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

2. Используй volatile для флагов

public class Worker implements Runnable {
    private volatile boolean running = true;
    
    @Override
    public void run() {
        while (running) {
            doWork();
        }
    }
    
    public void stop() {
        running = false;
    }
}

3. Используй AtomicReference для атомных операций

public class AtomicExample {
    private AtomicReference<User> currentUser = new AtomicReference<>();
    
    public void setUser(User user) {
        currentUser.set(user);
    }
    
    public User getUser() {
        return currentUser.get();
    }
}

4. Используй Lock для сложных операций

public class LockExample {
    private Lock lock = new ReentrantLock();
    private int value = 0;
    
    public void incrementTwice() {
        lock.lock();
        try {
            value++;  // Операция 1
            value++;  // Операция 2
            // Обе операции атомичны
        } finally {
            lock.unlock();
        }
    }
}

Почему JMM критична для многопоточности

1. Предсказуемость — программа работает одинаково на всех платформах
2. Корректность — гарантирует, что потоки видят друг друга изменения
3. Оптимизация — компилятор и CPU могут оптимизировать, не нарушая гарантий
4. Безопасность — защищает от race conditions и data races
5. Портативность — код работает на однопроцессорных и многопроцессорных системах

Ошибки без понимания JMM

// ❌ Опасно
public class Unsafe {
    private int value = 0;  // Без synchronize/volatile
    
    public void thread1() {
        value = 42;
    }
    
    public void thread2() {
        System.out.println(value);  // Непредсказуемо!
    }
}

Заключение

Java Memory Model — это контракт между JVM и программистом:

• JVM обещает соблюдать гарантии JMM
• Программист обязан использовать synchronized, volatile, locks и другие механизмы
• Без JMM многопоточная программа была бы совершенно непредсказуемой
• Понимание JMM — критически важно для написания корректного многопоточного кода