Semaphore Класс

Ссылка

Определение

Пространство имен:: Java.Util.Concurrent

Сборка:: Mono.Android.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

Семафор для подсчета.

[Android.Runtime.Register("java/util/concurrent/Semaphore", DoNotGenerateAcw=true)]
public class Semaphore : Java.Lang.Object, IDisposable, Java.Interop.IJavaPeerable, Java.IO.ISerializable

[<Android.Runtime.Register("java/util/concurrent/Semaphore", DoNotGenerateAcw=true)>]
type Semaphore = class
    inherit Object
    interface ISerializable
    interface IJavaObject
    interface IDisposable
    interface IJavaPeerable

Наследование: Object

Object
Semaphore

Атрибуты: RegisterAttribute

Реализации: IJavaObject IJavaPeerable ISerializable IDisposable

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

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

{@code
            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 вызове не удерживается блокировка синхронизации, так как это помешает возврату элемента в пул. Семафор инкапсулирует синхронизацию, необходимую для ограничения доступа к пулу, отдельно от любой синхронизации, необходимой для поддержания согласованности самого пула.

Семафор, инициализированный одним и который используется таким образом, чтобы у него было только одно доступное разрешение, может служить взаимной блокировкой исключения. Это чаще называется двоичным <семафором< em>>, так как он имеет только два состояния: одно разрешение доступно или ноль разрешений. При использовании таким образом двоичный семафор имеет свойство (в отличие от многих java.util.concurrent.locks.Lock реализаций), которое " lock" может быть освобожден потоком, который не является владельцем (так как семафоры не имеют понятия собственности). Это может быть полезно в некоторых специализированных контекстах, таких как восстановление взаимоблокировки.

Конструктор для этого класса при необходимости принимает <параметр em>fairness</em> . Если задано значение false, этот класс не гарантирует порядок, в котором потоки получают разрешения. В частности, <разрешено использование em>barging</em> , то есть вызову потока можно выделить разрешение перед ожидающим #acquire потоком. Логически новый поток помещается в начало очереди ожидающих потоков. Если для справедливости задано значение true, семафор гарантирует, что потоки, вызывающие любой из #acquire() acquire методов, будут выбраны для получения разрешений в том порядке, в котором был обработан их вызов этих методов (первым в порядке ожидания; FIFO). Обратите внимание, что порядок FIFO обязательно применяется к определенным внутренним точкам выполнения в этих методах. Таким образом, один поток может вызываться acquire перед другим, но достичь точки упорядочения после другого и аналогично при возвращении из метода . Также обратите внимание, что несвоевременные #tryAcquire() tryAcquire методы не учитывают параметры справедливости, но будут принимать все доступные разрешения.

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

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

Эффекты согласованности памяти. Действия в потоке перед вызовом метода "release", такие как release()<действия i>happen-before</i> после успешного метода "получения", acquire() например в другом потоке.

Добавлено в версии 1.5.

Документация по Java для java.util.concurrent.Semaphore.

Части этой страницы являются изменениями, основанными на работе, созданной и совместно используемой проектом и используемой в соответствии с условиями, Creative Commons 2.5 Attribution License Creative Commons 2.5 Attribution License.

Конструкторы

Semaphore(Int32)	`Semaphore` Создает объект с заданным количеством разрешений и параметром nonfair fairness.
Semaphore(Int32, Boolean)	Создает объект `Semaphore` с заданным числом разрешений и заданным параметром справедливости.
Semaphore(IntPtr, JniHandleOwnership)	Конструктор, используемый при создании управляемых представлений объектов JNI; вызывается средой выполнения.

Свойства

Class	Возвращает класс среды выполнения данного объекта `Object`. (Унаследовано от Object)
Handle	Дескриптор базового экземпляра Android. (Унаследовано от Object)
HasQueuedThreads	Запрашивает, ожидают ли какие-либо потоки получения.
IsFair	Возвращает значение `true` , если для этого семафора задано значение true.
JniIdentityHashCode	Семафор для подсчета. (Унаследовано от Object)
JniPeerMembers	Семафор для подсчета.
PeerReference	Семафор для подсчета. (Унаследовано от Object)
QueuedThreads	Возвращает коллекцию, содержащую потоки, которые могут ожидать получения.
QueueLength	Возвращает оценку количества потоков, ожидающих получения.
ThresholdClass	Этот API поддерживает инфраструктуру Mono для Android и не предназначен для использования непосредственно из кода.
ThresholdType	Этот API поддерживает инфраструктуру Mono для Android и не предназначен для использования непосредственно из кода.

Методы

Acquire()	Получает разрешение от этого семафора, блокируя его, пока он не будет доступен, или поток не прерван Поток#прерывание.
Acquire(Int32)	Получает заданное число разрешений от этого семафора, блокируя все, или поток не будет прерван потоком#прерывание.
AcquireUninterruptibly()	Получает разрешение от этого семафора, блокируя его до тех пор, пока он не будет доступен.
AcquireUninterruptibly(Int32)	Получает заданное количество разрешений от этого семафора, блокируя, пока все не будут доступны.
AvailablePermits()	Возвращает текущее количество разрешений, доступных в этом семафоре.
Clone()	Создает и возвращает копию этого объекта. (Унаследовано от Object)
Dispose()	Семафор для подсчета. (Унаследовано от Object)
Dispose(Boolean)	Семафор для подсчета. (Унаследовано от Object)
DrainPermits()	Получает и возвращает все разрешения, которые немедленно доступны, или, если имеются отрицательные разрешения, освобождает их.
Equals(Object)	Указывает, равен ли какой-то другой объект этому объекту. (Унаследовано от Object)
GetHashCode()	Возвращает значение хэш-кода для объекта. (Унаследовано от Object)
JavaFinalize()	Вызывается сборщиком мусора для объекта , когда сборка мусора определяет, что больше нет ссылок на объект . (Унаследовано от Object)
Notify()	Пробуждение одного потока, ожидающего на мониторе этого объекта. (Унаследовано от Object)
NotifyAll()	Активирует все потоки, ожидающие на мониторе этого объекта. (Унаследовано от Object)
ReducePermits(Int32)	Сокращает количество доступных разрешений на указанное сокращение.
Release()	Отпускает разрешение, возвращая его в семафор.
Release(Int32)	Освобождает заданное количество разрешений, возвращая их в семафор.
SetHandle(IntPtr, JniHandleOwnership)	Задает свойство Handle. (Унаследовано от Object)
ToArray<T>()	Семафор для подсчета. (Унаследовано от Object)
ToString()	Возвращает строковое представление объекта. (Унаследовано от Object)
TryAcquire()	Получает разрешение от этого семафора, только если оно доступно во время вызова.
TryAcquire(Int32)	Получает заданное количество разрешений от этого семафора, только если все они доступны во время вызова.
TryAcquire(Int32, Int64, TimeUnit)	Получает заданное число разрешений из этого семафора, если все они станут доступны в течение заданного времени ожидания и текущий поток не был прерван потоком#прерывание.
TryAcquire(Int64, TimeUnit)	Получает разрешение от этого семафора, если он становится доступным в течение заданного времени ожидания и текущий поток не был прерван Поток#прерывание.
UnregisterFromRuntime()	Семафор для подсчета. (Унаследовано от Object)
Wait()	Заставляет текущий поток ждать, пока он не будет пробужден, как правило, из-за <уведомления/><em> или <прерывания></em>. (Унаследовано от Object)
Wait(Int64)	Заставляет текущий поток ждать, пока он не будет пробужден, как правило, из-за <уведомления</>em>, <>прерывания< или> em, либо до истечения определенного количества реального времени. (Унаследовано от Object)
Wait(Int64, Int32)	Заставляет текущий поток ждать, пока он не будет пробужден, как правило, из-за <уведомления</>em>, <>прерывания< или> em, либо до истечения определенного количества реального времени. (Унаследовано от Object)

Явные реализации интерфейса

IJavaPeerable.Disposed()	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.DisposeUnlessReferenced()	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.Finalized()	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.JniManagedPeerState	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.SetJniIdentityHashCode(Int32)	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.SetJniManagedPeerState(JniManagedPeerStates)	Семафор для подсчета. (Унаследовано от Object)
IJavaPeerable.SetPeerReference(JniObjectReference)	Семафор для подсчета. (Унаследовано от Object)

Методы расширения

JavaCast<TResult>(IJavaObject)	Выполняет преобразование типа, проверенное средой выполнения Android.
JavaCast<TResult>(IJavaObject)	Семафор для подсчета.
GetJniTypeName(IJavaPeerable)	Семафор для подсчета.

Применяется к

Share via