• Только один поток может владеть блокировкой
• Операции
  • lock — получить блокировку
  • unlock — отдать блокировку

• Любой объект может служить блокировкой
  • Снятие блокировки производится автоматически
• Синтаксис

  synchronized (o) { // Получение блокировки
  …
  } // Снятие блокировки
  

• Метод экземпляра может быть объявлен синхронизованным

  public synchronized int getValue() { … }
  

• Эквивалентно

  public int getValue() {
      synchronized (this) { … }
  }
  

• Метод класса может быть объявлен синхронизованным

  class Example {
      public static synchronized int getValue() { … }
  … }
  

• Эквивалентно

  class Example {
      public static int getValue() {
          synchronized (Example.class) { … }
      }
  … }
  

• Несколько потоков производят данные
• Несколько потоков потребляют данные
• Данные могут храниться в очереди (не)ограниченного объема

• Хранит один элемент

  class Queue<T> {
      private E data;
      public void set(E data) { … }
      public E get() { … }
  }
  

• Установка значения

  public void set(E data) {
      while (true) { // Активное ожидание
          synchronized (this) {
              if (this.data == null) {
                  this.data = data;
                  break;
              }
          }
      }
  }
  

• Получение значения

  public E get() {
      while (true) { // Активное ожидание
          synchronized (this) {
              if (data != null) {
                  E d = data;
                  data = null;
                  return d;
              }
          }
      }
  }
  

• Любой объект может быть монитором
• Передача событий
  • Ожидание условия
    • wait(time?)
  • Извещение одного из ждущих потоков
    • notify()
  • Извещение всех ждущих потоков
    • notifyAll()
• Нужно владеть блокировкой
  • IllegalMonitorStateException

• При ожидании монитора блокировка с него снимается
• При извещении поток не получает управления, пока не получит блокировку обратно
• Псевдокод

  monitor.unlock()
  monitor.await()
  monitor.lock()
  

• Установка значения

  public synchronized void set(E data)
      throws InterruptedException
  {
      while (this.data != null) {
          wait(); // Пассивное ожидание
      }
      this.data = data;
      notifyAll();
  }
  

• Получение значения

  public synchronized E get()
      throws InterruptedException {
      while (data == null) {
          wait(); // Пассивное ожидание
      }
      E d = data;
      data = null;
      notifyAll();
      return d;
  }
  

• События одного вида
  • Может обработать любой ждущий поток
  • notify()
• Несколько видов событий
  • Пробуждение «не того» потока
  • notifyAll()
  • Более дорогая операция

• wait() может завершиться без notify()
  • Проверить наступление события
  • Ожидать всегда в цикле
• Идиома

  while (требуемое условие) {
      wait();
  }
  

• Разделяемые переменные инкапсулированы в мониторе
• Код в мониторе исполняется не более чем одним потоком
• Условия
• Операции с условиями
  • wait ‒ ожидание условия
  • notify ‒ сообщение об условии одному потоку
  • notifyAll ‒ сообщение об условии всем потокам

• Любой объект
  • Все методы synchronized
  • Одно событие
• На блокировках
  • Ручная синхронизация
  • Много событий

• Блокировка между операциями отпускается
  • Составные операции не атомарны
  • Конкуренция за блокировку
  • Java: огрубление блокировок
• Пример

  if (!queue.isEmpty()) {
      // Fail
      Object o = queue.poll();
  }
  

• Что может увидеть операция чтения
• Однопоточная модель
  • Результаты последней записи
• Многопоточная модель
  • Что такое последняя запись?

• Результат эквивалентен какому-то последовательному исполнению
  • Внутри потока — в порядке кода
  • Между потоками — произвольные переключения
• Не гарантируется Java
  • Иначе нельзя использовать регистры

• Атомарная операция выполняется как единое целое
  • Значения не появляются «из ниоткуда»
• Чтение и присвоение значений являются атомарными
  • Кроме long и double

• Программа
  • Разделяемая переменная

    int a = 0;
    

  • Поток 1

    a = -1;
    

  • Поток 2

    System.out.println(a);
    

• Возможные результаты
  • 0, −1

• Программа
  • Разделяемая переменная

    long a = 0;
    

  • Поток 1

    a = -1;
    

  • Поток 2

    System.out.println(a);
    

• Возможные результаты
  • 0, −1
  • 0xffffffff, 0xffffffff00000000
  • 2, 3
  • …

• T₂ видит изменения, произведенные T₁
• Гарантировано
  • T₂ захватил блокировку, отпущенную T₁
  • T₁ запустил T₂
  • T₂ дождался окончания T₁
• Возможно
  • Любые другие изменения
• При неправильной синхронизации изменения могут быть видимы в произвольном порядке

• Программа
  • Разделяемые переменные

    int a = 0;
    int b = 0;
    

  • Поток 1

    a = 10;
    b = 2;
    

  • Поток 2

    System.out.println(a + b);
    

• Возможные результаты
  • 0, 10, 12
  • 2

• Со своей точки зрения
  • Поток выполняется последовательно
• С точки зрения других потоков
  • Выполнение может производиться в произвольном порядке

• Программа
  • Разделяемая переменная

    int a = 0;
    

  • Поток

    a = 1;
    a = 2;
    

• Возможные видимые последовательности значений а
  • 0…, 0…01…, 0…02…, 0…01…12…, 1…12…, 2…
  • 2…20…, 2…21…, 0…01…10…

• Всегда атомарны
• Чтение из общей памяти
• Запись в общую память
• Чтения и записи глобально упорядочены
  • Видимость изменений: T₁ записал, T₂ прочитал

• Программа
  • Разделяемая переменная

    volatile List<String> list = null;
    

  • Поток 1

    List<String> l = new ArrayList<>();
    l.add("Hello");
    list = l;
    

  • Поток 2

    while (list == null) { }
    return list.get(0);
    

• Не работает без volatile

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

• Не работает без volatile

public void run() { // 0
    synchronized (o1) { // 1
        o1.notifyAll(); // 2
        synchronized (o2) { // 3
            try {
                o2.wait(); // unlock 4, await 5, lock 6
            } catch (InterruptedException e) {}
        } // 7
    } // 8
}

• Потоки дожидаются окончания друг друга

  public await(Barrier that) { // 0
      synchronized (this) { // 1
          this.gen++;     // 2
          this.notify();    // 3
      } // 4
      synchronized (that) { // 5
          while (this.gen > that.gen) { // 6
              that.wait(); // unlock 7, await 8, lock 9
          } // 10
      } // 11
  }
  

• Не изменяются с момента создания
  • Все поля final
  • Ссылаются только на неизменяемые объекты
• Потокобезопасны
  • Синхронизация не требуется
• Immutable

• Не изменяются с определенного момента
  • Вся инициализация в одном потоке
  • Ссылаются только на (эффективно) неизменяемые объекты
• Потокобезопасны
  • Корректно опубликованы
• Effectively immutable

• Корректное получение ссылки на объект
  • Полностью инициализирован
  • Опубликован с барьером
  • Получен с барьером
• Ссылки до окончания конструктора
  • Переопределяемые методы
  • Регистрация слушателей

• Внутренняя синхронизация
  • Для одиночных операций синхронизация не требуется
  • Внешняя синхронизация при массовых операциях
• Thread-safe

• Внешняя синхронизация
  • Синхронизация требуется для всех операций
  • Ответственность на вызывающем
• Conditionally thread-safe

• Не могут использоваться в многопоточной среде
  • Патологический случай
  • Глобальные переменные
  • Надо избегать
• Thread-hostile

• Одно поле
  • Ссылка не изменяется
  • Потокобезопасный объект
  • Атомарные или независимые операции
• Можно делегировать всю синхронизацию

• Один поток – один экземпляр
  • Thread-local objects
• Проблемы с взаимодействием

• Существует по одному на каждый поток
  • Каждый может использовать безопасно
• Доступ
  • Идентификатор
  • Чтение локального объекта
  • Запись локального объекта

• Класс ThreadLocal<T>
• Конструкторы
  • ThreadLocal() – новый идентификатор
• Методы
  • get() – чтение
  • set(value) – запись
  • remove() – удаление
• Реализация
  • initialValue() – исходное значение

• Наследуется при создании потока
• Класс InheritableThreadLocal<T> extends ThreadLocal<T>
• Методы
  • childValue(value) – значение для потомка

• Работать с разделяемыми значениями только под блокировкой
  • Взял блокировку
  • Прочел/изменил значение
  • Отпустил блокировку
• Мало блокировок
  • При отсутствии правильной синхронизации потоки могут увидеть практически что угодно
• Много блокировок
  • Взаимная блокировка

• Используйте notify[All]() / wait()
  • Всегда под блокировкой
  • Различайте события
• Не допускайте активного ожидания

• https://deadlockempire.github.io/

• JLS. Threads and Locks // https://docs.oracle.com/javase/specs/jls/se21/
  html/jls-17.html
• Concurrency (Java Tutorial) // http://docs.oracle.com/javase/tutorial/essential/
  concurrency/
• Java Memory Model Pragmatics // http://shipilev.net/blog/2014/jmm-pragmatics/
• Lea D. Concurrent Programming in Java
• Goetz B. Java Concurrency in Practice