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<Thread> 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()归还许可证。

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

五、原文参考

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

推荐阅读更多精彩内容