Semaphore 计数信号量方法及简单实例

说明

1.Semaphore中管理着一组虚拟的许可(permit)

• 许可的初始数量可通过构造函数来指定。
• 在执行操作时可以首先通过调用acquire方法获得许可(只要还有剩余的许可)，并在使用以后调用release方法释放许可。
• 如果没有许可，那么acquire方法将阻塞直到有许可(或者直到被中断或者操作超时)。
• release方法将返回一个许可给信号量。

2.用于控制资源访问的信号量应该被初始化为公平的，以确保没有线程因访问资源而被耗尽。在将信号量用于其他类型的同步控制时，非公平排序的吞吐量优势往往超过公平模式。

简单的应用场景

1.计数信号量可以用来实现资源池，或者对容器施加边界（默认是非公平的）

2.可以用做互斥体。计算信号量的一种简化形式是二值信号量，即初始值为1的Semaphore。二值信号量可以用做互斥体(mutex),并具备不可重入的加锁语义:谁拥有这个唯一的许可， 谁就拥有了互斥锁。这在某些特定的上下文中很有用，例如死锁恢复。

方法说明

// 创建具有给定的许可数和非的公平设置的 Semaphore。
Semaphore(int permits)
// 创建具有给定的许可数和给定的公平设置的 Semaphore。
Semaphore(int permits, boolean fair)

// 从此信号量获取一个许可，在获取许可前一直将线程阻塞，线程被中断会抛出异常。
void acquire()
// 从此信号量获取给定数目的许可，在获取许可前一直将线程阻塞，线程被中断会抛出异常。
void acquire(int permits)
// 从此信号量中获取许可，在获取许可前一直将线程阻塞。
void acquireUninterruptibly()
// 从此信号量获取给定数目的许可，在获取许可前一直将线程阻塞。
void acquireUninterruptibly(int permits)
// 返回此信号量中当前可用的许可数。
int availablePermits()
// 获取并返回立即可用的所有许可。
int drainPermits()
// 返回一个 collection，包含可能等待获取的线程。
protected Collection<Thread> getQueuedThreads()
// 返回正在等待获取的线程的估计数目。
int getQueueLength()
// 查询是否有线程正在等待获取。
boolean hasQueuedThreads()
// 如果此信号量的公平设置为 true，则返回 true。
boolean isFair()
// 根据指定的缩减量减小可用许可的数目。
protected void reducePermits(int reduction)
// 释放一个许可，将其返回给信号量。
void release()
// 释放给定数目的许可，将其返回到信号量。
void release(int permits)
// 返回标识此信号量的字符串，以及信号量的状态。
String toString()
// 仅在调用时此信号量存在一个可用许可，才从信号量获取许可。
boolean tryAcquire()
// 仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。
boolean tryAcquire(int permits)
// 如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。
boolean tryAcquire(int permits, long timeout, TimeUnit unit)
// 如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。
boolean tryAcquire(long timeout, TimeUnit unit)

代码

public static void main(String[] args) throws Exception {
        ExecutorService executorService = Executors.newCachedThreadPool();
        final Semaphore semaphore = new Semaphore(2);
        final CountDownLatch countDownLatch = new CountDownLatch(1);//使用闭锁使线程同步启动
        for (int i = 0; i < 5; i++) {
            final int count = i;
            executorService.execute(() -> {
                try {
                    countDownLatch.await();
                    semaphore.acquire(1);
                    resolve(count);
                    semaphore.release(1);
                } catch (Exception e) {
                    System.out.println(e);
                }
               
            });
        }
 		countDownLatch.countDown();
        executorService.shutdown();
    }

    private static void resolve(int i) throws InterruptedException {
        System.out.println("模拟处理中，i="+i);
        Thread.sleep(1000);
    }

结果

模拟处理中，i=0
模拟处理中，i=1
模拟处理中，i=2
模拟处理中，i=3
模拟处理中，i=4