JAVA多线程-Semaphore信号量

一、概述

Semaphore（信号量）是一个线程同步结构，用于在线程间传递信号，以避免出现信号丢失，或者像锁一样用于保护一个关键区域，可以控制同时访问的线程个数，并且通过acquire()方法获取一个许可，如果没有则等待，而release()方法会释放一个许可。

二、应用场景

Semaphore可以用于做流量控制，特别公用资源有限的应用场景，比如数据库连接

三、使用方法

3.1、默认构造器

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

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

在上面两个构造器方法中，其中permits标识许可的数目，即可以同时允许多少个线程进行许可访问，而fair这个参数则表示是否是公平的，即等待时间越久的线程越能优先获得许可访问的权限。

3.2、重要方法

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

public void release() {
    sync.releaseShared(1);
}

public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

上面4个方法中，前两个表示获取许可，后两个表示释放许可，其中，acquire()用来获取一个许可，而acquire(int permits)则是用来获取permits个许可，如果暂时无许可可获取，则会一直等待，直到获得许可；release()表示释放许可，而release(int permits)则是表示释放permits个许可，另外在调用这两个方法的时候需要注意，在释放许可之前，必须要先获得许可才行。

除此之外，上面4个方法在被调用后都会出现阻塞，而如果我们想立即得到执行结果，则可以直接使用下面几个方法：

尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false。

/**
 * 尝试获取一个许可，若获取成功，则立即
 * 返回true，若获取失败，则立即返回false
 */
public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
}

尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

/**
 * 尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，* 否则则立即返回false
 */
public boolean tryAcquire(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false

/**
 * 尝试获取permits个许可，若获取成功，则立即返回true，若获取失* 败，则立即返回false
 */
public boolean tryAcquire(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
}

尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

/**
 * 尝试获取permits个许可，若在指定的时间内获取成功，则立即返回* true，否则则立即返回false
 */
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

3.3、其他方法

返回此信号量中当前可用的许可证数

public int availablePermits() {
    return sync.getPermits();
}

返回正在等待获取许可证的线程数

public final int getQueueLength() {
    return sync.getQueueLength();
}

是否有线程正在等待获取许可证

public final boolean hasQueuedThreads() {
    return sync.hasQueuedThreads();
}

减少reduction个许可证。是个protected方法

protected void reducePermits(int reduction) {
    if (reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
}

返回所有等待获取许可证的线程集合。是个protected方法

protected Collection getQueuedThreads() {
    return sync.getQueuedThreads();
}

四、代码示例

我们假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用。那么对于这样一种情况，我们就可以通过Semaphore来实现：

package com.feizi.java.concurrency.tool;

import java.util.concurrent.Semaphore;

/**
 * Created by feizi on 2018/6/5.
 */
public class TestSemaphore {
    public static void main(String[] args) {
        //工人数
        int N = 8;

        //机器数目
        Semaphore semaphore = new Semaphore(5);

        for (int i = 0; i < N; i++){
            new Worker(i, semaphore).start();
        }
    }

    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;

        public Worker(int num, Semaphore semaphore) {
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                //通过信号量获取许可
                semaphore.acquire();

                System.out.println("工人 " + this.num + " 占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人 "  + this.num + " 释放出机器...");

                //释放许可
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

控制台输出结果：

工人 0 占用一个机器在生产...
工人 1 占用一个机器在生产...
工人 3 占用一个机器在生产...
工人 5 占用一个机器在生产...
工人 4 占用一个机器在生产...
工人 0 释放出机器...
工人 5 释放出机器...
工人 7 占用一个机器在生产...
工人 4 释放出机器...
工人 1 释放出机器...
工人 3 释放出机器...
工人 6 占用一个机器在生产...
工人 2 占用一个机器在生产...
工人 7 释放出机器...
工人 6 释放出机器...
工人 2 释放出机器...

Process finished with exit code 0

从上面输出结果，我们可以看到，虽然有8个工人（即8个线程），但是只有5台机器（即只允许5个工人同时工作，也就是5个线程并发的执行）。

Semaphore的构造方法Semaphore(int permits)接收一个整型的参数，表示可用的许可证数量。Semaphore(5)表示只允许5个线程获取许可证，也就是最大并发数是5。而在使用的时候，是首先使用Semaphore的acquire()获取一个许可证，使用完之后调用release()归还许可证。

某种程度上，我们暂时可以简单地理解成锁，因为和锁的机制有些类似，一般用于控制对某组资源的访问权限。

五、原文参考

http://ifeve.com/concurrency-semaphore/
http://www.importnew.com/21889.html