Java多线程之Semaphore实现信号灯

目录

• 1 Semaphore的主要方法
• 2 实例讲解
  • 实现单例模式
• 3 源码解析
  • 构造方法
  • 获取许可
  • 释放许可
  • 减小许可数量
  • 获取剩余许可数量

前言：

Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。
Semaphore可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。

1 Semaphore的主要方法

Semaphore(int permits):构造方法，创建具有给定许可数的计数信号量并设置为非公平信号量。

Semaphore(int permits,boolean fair):构造方法，当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。

void acquire():当前线程尝试去阻塞的获取1个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了1个可用的许可证，则会停止等待，继续执行。
• 当前线程被中断，则会抛出InterruptedException异常，并停止等待，继续执行。

void acquire(int n):从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。
当前线程尝试去阻塞的获取多个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了n个可用的许可证，则会停止等待，继续执行。
• 当前线程被中断，则会抛出InterruptedException异常，并停止等待，继续执行。

void release():释放一个许可，将其返回给信号量。

void release(int n):释放n个许可。

int availablePermits()：当前可用的许可数。
void acquierUninterruptibly():当前线程尝试去阻塞的获取1个许可证(不可中断的)。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了1个可用的许可证，则会停止等待，继续执行。

void acquireUninterruptibly(permits):当前线程尝试去阻塞的获取多个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了n个可用的许可证，则会停止等待，继续执行。

boolean tryAcquire()当前线程尝试去获取1个许可证。

• 此过程是非阻塞的，它只是在方法调用时进行一次尝试。
• 如果当前线程获取了1个可用的许可证，则会停止等待，继续执行，并返回true。
• 如果当前线程没有获得这个许可证，也会停止等待，继续执行，并返回false。

boolean tryAcquire(permits)：当前线程尝试去获取多个许可证。

• 此过程是非阻塞的，它只是在方法调用时进行一次尝试。
• 如果当前线程获取了permits个可用的许可证，则会停止等待，继续执行，并返回true。
• 如果当前线程没有获得permits个许可证，也会停止等待，继续执行，并返回false。

boolean tryAcquire(timeout,TimeUnit)：当前线程在限定时间内，阻塞的尝试去获取1个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了可用的许可证，则会停止等待，继续执行，并返回true。
• 当前线程等待时间timeout超时，则会停止等待，继续执行，并返回false。
• 当前线程在timeout时间内被中断，则会抛出InterruptedException一次，并停止等待，继续执行。

boolean tryAcquire(permits,timeout,TimeUnit)：当前线程在限定时间内，阻塞的尝试去获取permits个许可证。

此过程是阻塞的，它会一直等待许可证，直到发生以下任意一件事：

• 当前线程获取了可用的permits个许可证，则会停止等待，继续执行，并返回true。
• 当前线程等待时间timeout超时，则会停止等待，继续执行，并返回false。
• 当前线程在timeout时间内被中断，则会抛出InterruptedException一次，并停止等待，继续执行。

2 实例讲解

public class SemaphoreTest {

    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        Executor executor = Executors.newCachedThreadPool();

        String[] name = {"Jack", "Pony", "Larry", "Martin", "James", "ZhangSan","Tree"};

        int[] age = {21,22,23,24,25,26,27};

        for(int i=0;i<7;i++)
        {
            Thread t1=new InformationThread(name[i],age[i]);
            executor.execute(t1);
        }
    }

    private static class InformationThread extends Thread {
        private final String name;
        private final int age;

        public InformationThread(String name, int age) {
            this.name = name;
            this.age = age;
        }


        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()
                        + ":大家好，我是" + name + "我今年" + age +
                        "当前时间段为：" + System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println(name + "要准备释放许可证了，当前时间为：" + System.currentTimeMillis());
                System.out.println("当前可使用的许可数为：" + semaphore.availablePermits());
                System.out.println("是否有正在等待许可证的线程：" + semaphore.hasQueuedThreads());
                System.out.println("正在等待许可证的队列长度(线程数量)：" + semaphore.getQueueLength());
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}

pool-1-thread-1:大家好，我是Jack我今年21当前时间段为：1543498535306
pool-1-thread-3:大家好，我是Larry我今年23当前时间段为：1543498535306
pool-1-thread-2:大家好，我是Pony我今年22当前时间段为：1543498535306
Pony要准备释放许可证了，当前时间为：1543498536310
Jack要准备释放许可证了，当前时间为：1543498536310
当前可使用的许可数为：0
Larry要准备释放许可证了，当前时间为：1543498536310
是否有正在等待许可证的线程：true
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：4
正在等待许可证的队列长度(线程数量)：4
当前可使用的许可数为：0
pool-1-thread-4:大家好，我是Martin我今年24当前时间段为：1543498536311
是否有正在等待许可证的线程：true
pool-1-thread-5:大家好，我是James我今年25当前时间段为：1543498536311
正在等待许可证的队列长度(线程数量)：2
pool-1-thread-6:大家好，我是ZhangSan我今年26当前时间段为：1543498536312
James要准备释放许可证了，当前时间为：1543498537315
Martin要准备释放许可证了，当前时间为：1543498537315
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：1
当前可使用的许可数为：0
是否有正在等待许可证的线程：false
pool-1-thread-7:大家好，我是Tree我今年27当前时间段为：1543498537316
正在等待许可证的队列长度(线程数量)：0
ZhangSan要准备释放许可证了，当前时间为：1543498537317
当前可使用的许可数为：1
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0
Tree要准备释放许可证了，当前时间为：1543498538319
当前可使用的许可数为：2
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0

以上是非公平信号量，将建立Semaphore对象的语句改为如下语句：

private static final Semaphore semaphore=new Semaphore(3,true);

pool-1-thread-1:大家好，我是Jack我今年21当前时间段为：1543498810563
pool-1-thread-3:大家好，我是Larry我今年23当前时间段为：1543498810564
pool-1-thread-2:大家好，我是Pony我今年22当前时间段为：1543498810563
Jack要准备释放许可证了，当前时间为：1543498811564
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：4
pool-1-thread-4:大家好，我是Martin我今年24当前时间段为：1543498811564
Larry要准备释放许可证了，当前时间为：1543498811568
当前可使用的许可数为：0
Pony要准备释放许可证了，当前时间为：1543498811568
是否有正在等待许可证的线程：true
当前可使用的许可数为：0
正在等待许可证的队列长度(线程数量)：3
是否有正在等待许可证的线程：true
pool-1-thread-5:大家好，我是James我今年25当前时间段为：1543498811568
正在等待许可证的队列长度(线程数量)：2
pool-1-thread-6:大家好，我是ZhangSan我今年26当前时间段为：1543498811568
Martin要准备释放许可证了，当前时间为：1543498812566
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：1
pool-1-thread-7:大家好，我是Tree我今年27当前时间段为：1543498812566
James要准备释放许可证了，当前时间为：1543498812572
当前可使用的许可数为：0
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0
ZhangSan要准备释放许可证了，当前时间为：1543498812572
当前可使用的许可数为：1
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0
Tree要准备释放许可证了，当前时间为：1543498813568
当前可使用的许可数为：2
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0

实现单例模式

将创建信号量对象语句修改如下：

private static final Semaphore semaphore=new Semaphore(1);

运行程序，结果如下：

pool-1-thread-1:大家好，我是Jack我今年21当前时间段为：1543499053898
Jack要准备释放许可证了，当前时间为：1543499054903
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：6
pool-1-thread-2:大家好，我是Pony我今年22当前时间段为：1543499054904
Pony要准备释放许可证了，当前时间为：1543499055907
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：5
pool-1-thread-3:大家好，我是Larry我今年23当前时间段为：1543499055907
Larry要准备释放许可证了，当前时间为：1543499056909
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：4
pool-1-thread-4:大家好，我是Martin我今年24当前时间段为：1543499056909
Martin要准备释放许可证了，当前时间为：1543499057913
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：3
pool-1-thread-5:大家好，我是James我今年25当前时间段为：1543499057913
James要准备释放许可证了，当前时间为：1543499058914
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：2
pool-1-thread-6:大家好，我是ZhangSan我今年26当前时间段为：1543499058915
ZhangSan要准备释放许可证了，当前时间为：1543499059919
当前可使用的许可数为：0
是否有正在等待许可证的线程：true
正在等待许可证的队列长度(线程数量)：1
pool-1-thread-7:大家好，我是Tree我今年27当前时间段为：1543499059919
Tree要准备释放许可证了，当前时间为：1543499060923
当前可使用的许可数为：0
是否有正在等待许可证的线程：false
正在等待许可证的队列长度(线程数量)：0

如上可知，如果将给定许可数设置为1，就如同一个单例模式，即单个停车位，只有一辆车进，然后这辆车出来后，下一辆车才能进。

3 源码解析

Semaphore有两种模式，公平模式和非公平模式。公平模式就是调用acquire的顺序就是获取许可证的顺序，遵循FIFO；而非公平模式是抢占式的，也就是有可能一个新的获取线程恰好在一个许可证释放时得到了这个许可证，而前面还有等待的线程。

构造方法

Semaphore有两个构造方法，如下：

   

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

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

获取许可

先从获取一个许可看起，并且先看非公平模式下的实现。首先看acquire方法，acquire方法有几个重载，但主要是下面这个方法

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

从上面可以看到，调用了Sync的acquireSharedInterruptibly方法，该方法在父类AQS中，如下：

public final void acquireSharedInterruptibly(int arg)
        throws InterruptedException {
    if (Thread.interrupted()) //如果线程被中断了，抛出异常
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0) //获取许可失败，将线程加入到等待队列中
        doAcquireSharedInterruptibly(arg);
}

AQS子类如果要使用共享模式的话，需要实现tryAcquireShared方法，下面看NonfairSync的该方法实现：

protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }

该方法调用了父类中的nonfairTyAcquireShared方法，如下：

final int nonfairTryAcquireShared(int acquires) {
            for (;;) {
                //获取剩余许可数量
                int available = getState();
                //计算给完这次许可数量后的个数
                int remaining = available - acquires;
                //如果许可不够或者可以将许可数量重置的话，返回
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

从上面可以看到，只有在许可不够时返回值才会小于0，其余返回的都是剩余许可数量，这也就解释了，一旦许可不够，后面的线程将会阻塞。看完了非公平的获取，再看下公平的获取，

代码如下：

protected int tryAcquireShared(int acquires) {
            for (;;) {
                //如果前面有线程再等待，直接返回-1
                if (hasQueuedPredecessors())
                    return -1;
                //后面与非公平一样
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining))
                    return remaining;
            }
        }

从上面可以看到，FairSync与NonFairSync的区别就在于会首先判断当前队列中有没有线程在等待，如果有，就老老实实进入到等待队列；而不像NonfairSync一样首先试一把，说不定就恰好获得了一个许可，这样就可以插队了。
看完了获取许可后，再看一下释放许可。

释放许可

释放许可也有几个重载方法，但都会调用下面这个带参数的方法，

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

releaseShared方法在AQS中，如下：

public final boolean releaseShared(int arg) {
        //如果改变许可数量成功
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

AQS子类实现共享模式的类需要实现tryReleaseShared类来判断是否释放成功，

实现如下：

protected final boolean tryReleaseShared(int releases) {
            for (;;) {
                //获取当前许可数量
                int current = getState();
                //计算回收后的数量
                int next = current + releases;
                if (next < current) // overflow
                    throw new Error("Maximum permit count exceeded");
                //CAS改变许可数量成功，返回true
                if (compareAndSetState(current, next))
                    return true;
            }
        }

从上面可以看到，一旦CAS改变许可数量成功，那么就会调用doReleaseShared()方法释放阻塞的线程。

减小许可数量

Semaphore还有减小许可数量的方法，该方法可以用于用于当资源用完不能再用时，这时就可以减小许可证。代码如下：

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

可以看到，委托给了Sync，Sync的reducePermits方法如下：

final void reducePermits(int reductions) {
          for (;;) {
              //得到当前剩余许可数量
              int current = getState();
              //得到减完之后的许可数量
              int next = current - reductions;
              if (next > current) // underflow
                  throw new Error("Permit count underflow");
              //如果CAS改变成功
              if (compareAndSetState(current, next))
                  return;
          }
      }

从上面可以看到，就是CAS改变AQS中的state变量，因为该变量代表许可证的数量。

获取剩余许可数量

Semaphore还可以一次将剩余的许可数量全部取走，该方法是drain方法，

如下：

public int drainPermits() {
        return sync.drainPermits();
    }

Sync的实现如下：

final int drainPermits() {
           for (;;) {
               int current = getState();
               if (current == 0 || compareAndSetState(current, 0))
                   return current;
           }
       }

可以看到，就是CAS将许可数量置为0。

4、总结

Semaphore是信号量，用于管理一组资源。其内部是基于AQS的共享模式，AQS的状态表示许可证的数量，在许可证数量不够时，线程将会被挂起；而一旦有一个线程释放一个资源，那么就有可能重新唤醒等待队列中的线程继续执行。

到此这篇关于Java多线程之Semaphore实现信号灯的文章就介绍到这了,更多相关Java多线程 Semaphore实现信号灯内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://juejin.cn/post/7019623653927026719