Класс Semaphore

public class Semaphore
extends Object
implements Serializable

Счётный семафор. Понятие семафора подразумевает набор разрешений. Каждый вызов acquire() блокируется при необходимости, пока разрешение не станет доступным, а затем его берёт. Каждый вызов release() добавляет разрешение, потенциально разблокируя заблокированный запрос. Однако, фактические объекты разрешений не используются; семафор просто отслеживает количество доступных разрешений и действует соответствующим образом.

Семафоры часто используются для ограничения количества потоков, которые могут получить доступ к некоторому (физическому или логическому) ресурсу. Например, вот класс, который использует семафор для управления доступом к пулу элементов:

class Pool {
   private static final int MAX_AVAILABLE = 100;
   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

   public Object getItem() throws InterruptedException {
     available.acquire();
     return getNextAvailableItem();
   }

   public void putItem(Object x) {
     if (markAsUnused(x))
       available.release();
   }

   // Not a particularly efficient data structure; just for demo

   protected Object[] items = ... whatever kinds of items being managed
   protected boolean[] used = new boolean[MAX_AVAILABLE];

   protected synchronized Object getNextAvailableItem() {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (!used[i]) {
         used[i] = true;
         return items[i];
       }
     }
     return null; // not reached
   }

   protected synchronized boolean markAsUnused(Object item) {
     for (int i = 0; i < MAX_AVAILABLE; ++i) {
       if (item == items[i]) {
         if (used[i]) {
           used[i] = false;
           return true;
         } else
           return false;
       }
     }
     return false;
   }
 }

Перед получением элемента каждый поток должен получить разрешение от семафора, гарантируя, что элемент доступен для использования. Когда поток закончил работу с элементом, он возвращается в пул, и разрешение возвращается семафору, что позволяет другому потоку получить этот элемент. Обратите внимание, что блокировка синхронизации не удерживается при вызове acquire(), так как это помешало бы возвращению элемента в пул. Семафор инкапсулирует необходимую синхронизацию для ограничения доступа к пулу отдельно от любой синхронизации, необходимой для поддержания согласованности самого пула.

Семафор, инициализированный единицей и используемый таким образом, что доступно не более одного разрешения, может служить блокировкой взаимного исключения. Это более известно как двоичный семафор, потому что он имеет только два состояния: одно разрешение доступно или ноль разрешений доступно. Когда он используется таким образом, двоичный семафор обладает свойством (в отличие от многих реализаций Lock), что «блокировка» может быть освобождена потоком, отличным от владельца (поскольку у семафоров нет понятия владения). Это может быть полезно в некоторых специализированных контекстах, таких как восстановление от тупиков.

Конструктор этого класса необязательно принимает параметр справедливости. При установке в значение false этот класс не даёт гарантий относительно порядка получения потоками разрешений. В частности, разрешается вторжение, то есть поток, вызывающий acquire(), может получить разрешение опережая поток, который ожидал — логически новый поток помещает себя в начало очереди ожидающих потоков. При установке справедливости в значение true семафор гарантирует, что потоки, вызывающие любые из методов acquire, выбираются для получения разрешений в порядке их вызова (первым пришёл, первым обслужен; FIFO). Обратите внимание, что упорядочивание FIFO обязательно для определённых внутренних точек выполнения в этих методах. Таким образом, один поток может вызвать acquire перед другим, но достичь точки упорядочения после другого, и аналогично при возвращении из метода. Также обратите внимание, что неуказанные методы tryAcquire не учитывают настройку справедливости, но возьмут любые доступные разрешения.

В целом, семафоры, используемые для управления доступом к ресурсам, должны быть инициализированы как справедливые, чтобы гарантировать, что ни один поток не лишается доступа к ресурсу. При использовании семафоров для других типов управления синхронизацией преимущества производительности несправедливого порядка часто перевешивают соображения справедливости.

Этот класс также предоставляет удобные методы для acquire и release нескольких разрешений одновременно. Эти методы обычно более эффективны и действенны, чем циклы. Однако они не устанавливают никакого предпочтения порядка. Например, если поток A вызывает s.acquire(3) и поток B вызывает s.acquire(2), и два разрешения становятся доступными, то нет никакой гарантии, что поток B получит их, если его запрос пришёл первым, а семафор s находится в режиме справедливости.

Эффекты согласованности памяти: Действия в потоке до вызова метода «release», такого как release() происходят раньше действий, следующих за успешным вызовом метода «acquire», таким как acquire() в другом потоке.