• Чтение
• Запись

• Инкремент
• Декремент

• get

• set

• getAndSet

• compareAndSet

• Если текущее значение равно old
• Записать значение new

do {
    oldV = v.get();
    newV = process(old);
} while (!v.compareAndSet(oldV, newV));

// Получение доступа к ресурсу
while (!v.compareAndSet(0, 1));
// Действия с ресурсом
// Освобождение ресурса
v.set(0);

• get() – атомарное чтение
• set(value) – атомарная запись
• lazySet(value) – запись без барьера
• getAndSet(value) – чтение и запись

• compareAndSet(expected, value) – сравнение и запись
• weakCompareAndSet(expected, value) – слабое сравнение и запись

• getAndIncrement() – инкремент
• getAndDecrement() – декремент
• getAndAdd(delta) – сложение

• incrementAndGet() – инкремент
• decrementAndGet() – декремент
• addAndGet(delta) – сложение

• java.util.concurrent.atomic

• AtomicBoolean
• AtomicInteger
• AtomicLong
• AtomicReference

• Обычные

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

• Обычные, с указанием индекса
• length() – число элементов

• AtomicIntegerFieldUpdater
• AtomicLongFieldUpdater
• AtomicReferenceFieldUpdater

• volatile
• не static

• Обычные, с указанием объекта
• Создание newUpdater(class, fieldName)

• LongAdder и DoubleAdder
• add(long) – прибавить
• sum() – сумма
• reset() – сбросить

• LongAccumulator и DoubleAccumulator
• LongAccumulator(op, zero) – создать
• accumulate(long) – добавить
• get() – значение
• reset() – сбросить

• Локализация обновлений
• Персистентные структуры данных
• Атомарное обновление результата
  • compareAndSet(expected, value)

• Первый — выигрывает
• Проблема ABA

• ссылка, помеченная флажком
• одноразовая

• ссылка, помеченная числом
• многоразовая

• getReference() – прочитать ссылку
• isMarked() / getStamp() – прочитать пометку
• V get(X[] holder) – прочитать ссылку и пометку

• set(valueV, valueX) – изменить пометку и значение
• attemptX(expectedV, valueX) – изменить пометку

• compareAndSet(oldV, newV, oldX, newX)

• lock – получить блокировку
• unlock – отдать блокировку
• tryLock – попробовать получить блокировку

• Пакет java.util.concurrent.locks

• lock() – захватить блокировку
• lockInterruptibly() – захватить блокировку
• tryLock(time?, unit?) – попытаться захватить блокировку
• unlock() – отпустить блокировку

• newCondition() – создать условие

• await(time?, unit?) – ждать условия
• awaitUntil(deadline) – ждать условия до времени
• awaitUninterruptibly() – ждать условие
• signal() – подать сигнал
• signalAll() – подать сигнал всем

• void set(Object data) throws InterruptedException {
      lock.lock();
      try {
          while (this.data != null) {
              notFull.await();
          }
          this.data = data;
          notEmpty.signal();
      } finally {
          lock.unlock();
      }
  }
  

• Необходимость явного отпускания

l.lock()
try {
    …
} finally {
    l.unlock()
}

• Производитель

  empty.lock();
  // копирование
  full.unlock();
  

• Потребитель

  full.lock();
  // копирование
  empty.unlock();
  

• isFair() – «честность» блокировки
• isLocked() – блокировка занята

• getQueuedThreads() / getQueueLength() / hasQueuedThread(thread) / hasQueuedThreads() – потоки, ждущие блокировку
• getWaitingThreads(condition) / getWaitQueueLength(condition) – потоки, ждущие условие

• readLock() – блокировка для читателей
• writeLock() – блокировка для писателей

〈name: statements〉

resource
〈
    resource:
    // Доступ к ресурсу
〉

〈await(!lock) lock = true;〉 // Вход
// Критическая секция
lock = false; // Выход

while (!lock.compareAndSet(0, 1));   // Вход
// Критическая секция
lock.set(0);    // Выход

• acquire — получить разрешение
• release — добавить разрешение

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

  do {
      do {
          p = permits.get();
      } while (p == 0);
  } while (!permits.compareAndSet(p, p - 1));
  

• Добавление разрешения

  do {
      p = permits.get();
  } while (!permits.compareAndSet(p, p + 1));
  

• Semaphore(n, fair?) – число разрешений и честность

• acquire(n?) – получить разрешение
• release(n?) – отдать разрешение
• tryAcquire(n?, time?, unit?) – попробовать получить разрешение
• reducePermits(n) – уменьшить число разрешений
• drainPermits() – забрать все разрешения
• статистика

• Одноразовый
• Многоразовый

• arrive — прибытие к барьеру

• Переход к следующему этапу

• CyclicBarrier(n, runnable?) – число потоков и действие на барьере

• await(time?, unit?) – барьер.
• reset() – возвращает барьер в исходное состояние
• isBroken() – «сломан» ли барьер
• статистика

• countDown() – опускает защелку на единицу
• await() – ждет спуска защелки

• CountDownLatch(n) – высота защелки

• await(time?, unit?) – ждет спуска защелки
• countDown() – опускает защелку на единицу
• getCount() – текущая высота защелки

• Инициализация

• Phaser

• register() – добавить фрагмент
• arrive() – фрагмент выполнен
• arriveAndAwaitAdvance() – и дождаться остальных
• arriveAndDeregister() – и больше никогда не ждать
• awaitAdvance(phase) – дождаться конца фазы

• Exchanger<V>

• exchange(value, time?, unit?) – обменяться

• Задание

  queue.add(task);
  queue.notify();
  task.wait();
  

• Работник

  while (queue.isEmpty()) {
      queue.wait();
  }
  Task t = queue.get();
  // Обработка задания
  t.notify();
  

• Все философы кроме одного берут сначала левую, затем правую вилку
• Оставшийся философ берет сначала правую, затем левую вилку

〈if (nr++ == 0) busy.lock();〉
// Чтение
〈if (--nr == 0) busy.unlock();〉

busy.lock();
// Запись
busy.unlock();

if (nw == 0 && dr > 0) {
    dr--;
    // Возобновить процесс-читатель
    r.unlock();
} else if (nr == 0 && nw == 0 && dw > 0) {
    dw--;
    // Возобновить процесс-писатель
    w.unlock();
} else {
    e.unlock(); // Открыть вход
}

e.lock();
if (nw > 0) { dr++; e.unlock(); r.lock(); }
// Доступ разрешен
nr++;
// Передача эстафеты
// Чтение
e.lock();
nr--;
// Передача эстафеты

e.lock();
if (nw > 0 || nr > 0) { dw++; e.unlock(); w.lock(); }
nw++;
// Передача эстафеты
// Запись
e.lock();
nw--;
// Передача эстафеты