Semaphore 类

定义

[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 不会保留任何同步锁，因为这样会阻止将项返回到池。 信号灯封装限制对池的访问所需的同步，与维护池本身一致性所需的任何同步分开。

初始化为 1 的信号灯，并且已使用它，因此它最多只能有一个可用许可证，可以充当相互排除锁。 这通常称为 em>二进制信号灯</em>，因为它只有两种状态：一个<可用许可证或零个可用许可证。 以这种方式使用时，二进制信号灯具有属性（与许多 java.util.concurrent.locks.Lock 实现不同），而 ”lock”可以由所有者以外的线程释放（因为信号灯没有所有权的概念）。 这在某些专用上下文（例如死锁恢复）中非常有用。

此类的构造函数（可选）接受 <em>fairness</em> 参数。 如果设置为 false，则此类无法保证线程获取许可证的顺序。 具体而言， <允许 em>barging</em> ，也就是说，在等待线程之前，可以分配线程调用 #acquire 的许可证 - 从逻辑上讲，新线程将自身置于等待线程队列的头。 如果公平性设置为 true，信号灯将保证调用任何 #acquire() acquire 方法的线程被选中，以处理这些方法的顺序获取许可证（先出先出;FIFO）。 请注意，FIFO 排序必然适用于这些方法内的特定内部执行点。 因此，一个线程可以在另一个线程之前调用 acquire ，但在另一个线程之后到达排序点，并在从方法返回时同样到达排序点。 另请注意，未设定时间 #tryAcquire() tryAcquire 的方法不遵循公平性设置，但将采用任何可用的许可证。

通常，用于控制资源访问的信号量应初始化为公平，以确保不会耗尽任何线程来访问资源。 将信号灯用于其他类型的同步控制时，非公平排序的吞吐量优势往往超过公平性注意事项。

此类还提供一次允许和#release(int) release多个许可的便利方法#acquire(int) acquire。 这些方法通常比循环更有效和有效。 但是，它们不会建立任何首选项顺序。 例如，如果线程 A 调用 s.acquire(3）和线程 B 调用 s.acquire(2)，并且两个许可证可用，则无法保证线程 B 将获取它们，除非其获取第一个，信号灯 s 处于公平模式。

内存一致性影响：在调用“release”方法之前线程中的操作，例如release()<，><在成功“获取”方法（例如acquire()在另一个线程中）之前执行/i> 操作。

在 1.5 中添加。

适用于 . 的 java.util.concurrent.SemaphoreJava 文档

本页的某些部分是根据 Android 开放源代码项目创建和共享的工作进行的修改，并根据 Creative Commons 2.5 属性许可证中所述的术语使用。