Semaphore

Semaphore计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 释放一个许可，从而可能使一个正在阻塞的获取者获取该许可。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

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

此类的构造方法可选地接受一个公平参数。当设置为false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用 acquire() 的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为true时，信号量保证对于任何调用获取方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。所以，可能某个线程先于另一个线程调用了 acquire，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的 tryAcquire 方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

构造函数：

创建具有给定的许可数和非公平的公平设置的 Semaphore。

public Semaphore(int permits) {
        sync = new NonfairSync(permits);
}

创建具有给定的许可数和给定的公平设置的 Semaphore。

public Semaphore(int permits, boolean fair) {
      sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

部分方法：

acquire()：
从信号量获取一个许可，在提供一个许可前一直将线程阻塞，除非线程被中断。获取一个许可（如果提供了一个）并立即返回，将可用的许可数减 1。

release()：
释放一个许可，将其返回给信号量。释放一个许可，将可用的许可数增加 1。

acquire(int permits)：
从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被 中断。获取给定数目的许可（如果提供了）并立即返回，将可用的许可数减去给定的量。

tryAcquire(int permits)：
仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。获取给定数目的许可（如果提供了）并立即返回，其值为 true，将可用的许可数减去给定的量。如果没有足够的可用许可，则此方法立即返回，其值为 false，并且不改变可用的许可数。

示例：

创建一个有界的容器：

package com.zero.test;

import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

public class SemaphoreTest {

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        BoundedHashSet<String> set = new BoundedHashSet<String>(3);
        new Thread(new Runnable() {
            @Override
            public void run() {
                // TODO Auto-generated method stub
                try {
                    set.add("123");
                    set.add("234");
                    set.add("345");
                    set.add("456");
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }).start();
        TimeUnit.SECONDS.sleep(3);
        set.remove("123");
    }
}

class BoundedHashSet<T> {
    private final Set<T> set;
    private final Semaphore semaphore;

    public BoundedHashSet(int bound) {
        this.set = Collections.synchronizedSet(new HashSet<T>());
        this.semaphore = new Semaphore(bound);
    }

    public boolean add(T o) throws InterruptedException {
        semaphore.acquire();
        boolean wasAdded = false;
        try {
            wasAdded = set.add(o);
            System.out.println("add : " + o);
            return wasAdded;
        } finally {
            if (!wasAdded) {
                semaphore.release();
            }
        }
    }

    public boolean remove(Object o) {
        boolean wasRemove = set.remove(o);
        if (wasRemove) {
            System.out.println("remove : " + o);
            semaphore.release();
        }
        return wasRemove;
    }
}