信号量Semaphore

java.util.concurrent.Semaphore是一个计数信号量。从概念上讲，信号量维护了一个许可集。
通过acquire()来获得一个许可，如果有许可可用，就返回，否则阻塞直到有许可可用。通过release() 来释放一个许可。
但是，不使用实际的许可对象，Semaphore 只对可用许可进行计数，并采取相应的行动。Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

例如，下面的类使用信号量控制对内容池的访问：

 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:"调用 acquire() 时无法保持同步锁,因为这会阻止将项返回到池中"因为如果调用acquire() 时保持同步锁，这时如果它被阻塞了，
调putItem(Object x)时，它又调用markAsUnused（）了，而markAsUnused（）需要同步锁。这时就死锁了。

信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：可用，不可用。
按此方式使用时，二进制信号量具有某种属性（与很多 Lock 实现不同），即可以由其他线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

注意1:因为信号量没有所有权的概念，非二进制的信号量当然也可以由其他线程释放许可，而不一定要是所有者。

Semaphore的构造方法可选地接受一个公平参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。
特别地，闯入是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，

从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用获取方法的线程而言，
都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。
注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。

还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。
为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。
此类还提供便捷的方法来同时 acquire 和释放多个许可。小心，在未将公平设置为 true 时使用这些方法会增加不确定延期的风险。
内存一致性效果：线程中调用“释放”方法（比如 release()）之前的操作 happen-before 另一线程中紧跟在成功的“获取”方法（比如 acquire()）之后的操作。
注意1:即使将公平参数设置为"true",会按照FIFO来选择线程，即先到达先被分配许可，但是先调用acquire,并不能保证该线程先到达。

主要函数：

public void acquire() throws InterruptedException
    从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
    获取一个许可（如果提供了一个）并立即返回，将可用的许可数减 1。
    如果没有可用的许可，则在发生以下两种情况之一前，禁止将当前线程用于线程安排目的并使其处于休眠状态：
        * 某些其他线程调用此信号量的 release() 方法，并且当前线程是下一个要被分配许可的线程；或者
        * 其他某些线程中断当前线程。
    如果当前线程：
        * 被此方法将其已中断状态设置为 on ；或者
        * 在等待许可时被中断。
    则抛出 InterruptedException，并且清除当前线程的已中断状态。
    抛出：InterruptedException - 如果当前线程被中断
注意1：它可以抛出InterruptedException

public void acquireUninterruptibly()
    从此信号量中获取许可，在有可用的许可前将其阻塞。
    获取一个许可（如果提供了一个）并立即返回，将可用的允许数减 1。
    如果没有可用的许可，则在其他某些线程调用此信号量的 release() 方法，并且当前线程是下一个要被分配许可的线程前，
    禁止当前线程用于线程安排目的并使其处于休眠状态。
    如果当前线程在等待许可时被中断，那么它将继续等待，但是与没有发生中断，其将接收允许的时间相比，为该线程分配许可的时间可能改变。
    当线程确实从此方法返回后，将设置其中断状态。
注意1："当线程确实从此方法返回后，将设置其中断状态"
这句话不正确。我觉得acquireUninterruptibly（）。如果阻塞，它仅仅是忽略对中断（即中断状态）的处理。
具体见例1,关于Interrupted的更多内容请参见《Interrupt》

public boolean tryAcquire()
    仅在调用时此信号量存在一个可用许可，才从信号量获取许可。
    获取一个许可（如果提供了一个）并立即返回，其值为 true，将可用的许可数减 1。
    如果没有可用的许可，则此方法立即返回并且值为 false。
    即使已将此信号量设置为使用公平排序策略，但是调用 tryAcquire() 也将立即获取许可（如果有一个可用），
    而不管当前是否有正在等待的线程。在某些情况下，此“闯入”行为可能很有用，即使它会打破公平性也如此。
    如果希望遵守公平设置，则使用 tryAcquire(0, TimeUnit.SECONDS) ，它几乎是等效的（它也检测中断）。
    返回：如果获取了许可，则返回 true；否则返回 false
注意1:即使已将此信号量设置为使用公平排序策略，但是调用 tryAcquire() 也将立即获取许可（如果有一个可用），而不管当前是否有正在等待的线程。

public boolean tryAcquire(long timeout,TimeUnit unit) throws InterruptedException
    如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。
    获取一个许可（如果提供了一个）并立即返回，其值为 true，将可用的许可数减 1。
    如果没有可用的允许，则在发生以下三种情况之一前，禁止将当前线程用于线程安排目的并使其处于休眠状态：
        * 其他某些线程调用此信号量的 release() 方法并且当前线程是下一个被分配许可的线程；或者
        * 其他某些线程中断当前线程；或者
        * 已超出指定的等待时间。
    如果获取了许可，则返回值为 true。
    如果当前线程：
        * 被此方法将其已中断状态设置为 on ；或者
        * 在等待获取许可的同时被中断。
    则抛出 InterruptedException，并且清除当前线程的已中断状态。
    如果超出了指定的等待时间，则返回值为 false。如果该时间小于等于 0，则方法根本不等待。
    参数：
        timeout - 等待许可的最多时间
        unit - timeout 参数的时间单位
    返回：如果获取了许可，则返回 true；如果获取许可前超出了等待时间，则返回 false
    抛出：InterruptedException - 如果当前线程是已中断的

public void release()
    释放一个许可，将其返回给信号量。
    释放一个许可，将可用的许可数增加 1。如果任意线程试图获取许可，则选中一个线程并将刚刚释放的许可给予它。
    然后针对线程安排目的启用（或再启用）该线程。
    不要求释放许可的线程必须通过调用 acquire() 来获取许可。通过应用程序中的编程约定来建立信号量的正确用法。

       Semaphore sem = new Semaphore(10, true);
       sem.release();
       sem.release();
       System.out.println(sem.availablePermits());//输出结果是12

public void acquire(int permits) throws InterruptedException
    从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。
    获取给定数目的许可（如果提供了）并立即返回，将可用的许可数减去给定的量。
    如果没有足够的可用许可，则在发生以下两种情况之一前，禁止将当前线程用于线程安排目的并使其处于休眠状态：
        * 其他某些线程调用此信号量的某个释放方法，当前线程是下一个被分配允许的线程并且可用许可的数目满足此请求；或者
        * 其他某些线程中断当前线程。
    如果当前线程：
        * 被此方法将其已中断状态设置为 on ；或者
        * 在等待许可时被中断。
    则抛出 InterruptedException，并且清除当前线程的已中断状态。任何原本应该分配给此线程的许可将被分配给其他试图获取许可的线程，
    就好像已通过调用 release() 而使许可可用一样。
    参数：
        permits - 要获取的许可数
    抛出：
        InterruptedException - 如果当前线程已被中断
        IllegalArgumentException - 如果 permits 为负

protected void reducePermits(int reduction)
    根据指定的缩减量减小可用许可的数目。此方法在使用信号量来跟踪那些变为不可用资源的子类中很有用。
    此方法不同于 acquire，在许可变为可用的过程中，它不会阻塞等待。
    参数：
        reduction - 要移除的许可数
    抛出：IllegalArgumentException - 如果 reduction 是负数

注意1:这个方法是"protected"的。关于此方法的使用请见例2

例1
static void semaphoreDemo()
    {
        try{
        sem.acquire() ;
        sem.acquire();
        sem.acquire();
        Thread t=new SemaphoreDemoThread(sem);
        t.start();
        t.interrupt();
        System.out.println("t is interruped:" +t.isInterrupted());
        sem.release();
        sem.release();
        sem.release();
        }catch(InterruptedException e)
        {
            
        }
    }
class SemaphoreDemoThread extends Thread
{
    Semaphore sem=null;

    SemaphoreDemoThread(Semaphore sem)
    {
    this.sem=sem;
    }
    public void run()
    {
        sem.acquireUninterruptibly();
    try{
            Thread.sleep(1);
        }catch(InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}
例2
       private static final int MAX_AVAILABLE = 3;
       private final static MySemaphore sem = new MySemaphore(MAX_AVAILABLE, true);
    static void semaphoreDemo()
    {
        try{
        sem.acquire() ;
        sem.acquire();
        sem.acquire();
        System.out.println("availablePermits:"+sem.availablePermits()+"before reduce");
        sem.reducePermits(2);
        System.out.println("availablePermits:"+sem.availablePermits()+"after reduce");
        sem.release();
        sem.release();
        System.out.println("availablePermits:"+sem.availablePermits()+"after realese two");
        sem.release();
        System.out.println("availablePermits:"+sem.availablePermits()+"after realese another one");
        }catch(InterruptedException e)
        {
            
        }
    }
class MySemaphore extends Semaphore
{
    MySemaphore(int permits)
    {
        super(permits);
    }
       MySemaphore(int permits, boolean fair)
       {
           super(permits,fair);
       }
    public void reducePermits(int reduction)
    {
        super.reducePermits(reduction);
    }
}

结果如下：
availablePermits:0before reduce
availablePermits:-2after reduce
availablePermits:0after realese two
availablePermits:1after realese another one

posted @ 2014-10-04 01:01 princessd8251 阅读(154) 评论(0) 收藏举报

刷新页面返回顶部