深入理解Semaphore原理

最新推荐文章于 2025-08-15 21:47:19 发布
最新推荐文章于 2025-08-15 21:47:19 发布
阅读量2.5k 收藏 9
点赞数 3
CC 4.0 BY-SA版权
分类专栏： 并发编程剖析 文章标签： 深入理解Semaphore原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BThinker/article/details/104395145
本文深入剖析Semaphore原理，包括非公平和公平模式下的资源获取与释放过程，以及如何使用Semaphore控制并发线程数，通过银行服务示例展示其应用。

                                    深入理解Semaphore原理

 一、简述

      Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有实际的许可证这个对象，Semaphore只是维持了一个可获得许可证的数量。 

Semaphore经常用于限制获取某种资源的线程数量。下面举个例子，比如说操场上有5个跑道，一个跑道一次只能有一个学生在上面跑步，一旦所有跑道在使用，那么后面的学生就需要等待，直到有一个学生不跑了。

在信号量上定义两种操作： acquire（获取） 和 release（释放）。当一个线程调用acquire操作时，它要么通过成功获取信号量（信号量减1），要么一直等下去，直到有线程释放信号量，或超时。release（释放）实际上会将信号量的值加1，然后唤醒等待的线程。

信号量主要用于两个目的，一个是用于多个共享资源的互斥使用，另一个用于并发线程数的控制。

在学习Semaphore之前我们可以先对同步器进行学习，这样有助于我们学习Semaphore
传送门：

深入理解AQS（AbstractQueuedSynchronizer）

深入理解CountDownLatch原理

深入理解ReentrantLock原理

深入理解CyclicBarrier原理

 二、源码解析

 Semaphore总共有三个内部类，并且三个内部类是紧密相关的，下面先看三个类的关系。

说明：Semaphore与ReentrantLock的内部类的结构相同，类内部总共存在Sync、NonfairSync、FairSync三个类，NonfairSync与FairSync类继承自Sync类，Sync类继承自AbstractQueuedSynchronizer抽象类。下面逐个进行分析。

2.1、Sync类

  Sync类的源码如下：

// 内部类，继承自AQS
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 版本号
        private static final long serialVersionUID = 1192457210091910933L;
        
        // 构造函数
        Sync(int permits) {
            // 设置状态数
            setState(permits);
        }
        
        // 获取许可
        final int getPermits() {
            return getState();
        }
 
        // 共享模式下非公平策略获取
        final int nonfairTryAcquireShared(int acquires) {
            for (;;) { // 无限循环
                // 获取许可数
                int available = getState();
                // 剩余的许可
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining)) // 许可小于0或者比较并且设置状态成功
                    return remaining;
            }
        }
        
        // 共享模式下进行释放
        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");
                if (compareAndSetState(current, next)) // 比较并进行设置成功
                    return true;
            }
        }
 
        // 根据指定的缩减量减小可用许可的数目
        final void reducePermits(int reductions) {
            for (;;) { // 无限循环
                // 获取许可
                int current = getState();
                // 可用的许可
                int next = current - reductions;
                if (next > current) // underflow
                    throw new Error("Permit count underflow");
                if (compareAndSetState(current, next)) // 比较并进行设置成功
                    return;
            }
        }
 
        // 获取并返回立即可用的所有许可
        final int drainPermits() {
            for (;;) { // 无限循环
                // 获取许可
                int current = getState();
                if (current == 0 || compareAndSetState(current, 0)) // 许可为0或者比较并设置成功
                    return current;
            }
        }
    }

说明：Sync类的属性相对简单，只有一个版本号，Sync类存在如下方法和作用如下：

2.2、NonfairSync类

NonfairSync类继承了Sync类，表示采用非公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法，其源码如下：

static final class NonfairSync extends Sync {
        // 版本号
        private static final long serialVersionUID = -2694183684443567898L;
        
        // 构造函数
        NonfairSync(int permits) {
            super(permits);
        }
        // 共享模式下获取
        protected int tryAcquireShared(int acquires) {
            return nonfairTryAcquireShared(acquires);
        }
    }

说明：从tryAcquireShared方法的源码可知，其会调用父类Sync的nonfairTryAcquireShared方法，表示按照非公平策略进行资源的获取。

2.3、FairSync类

FairSync类继承了Sync类，表示采用公平策略获取资源，其只有一个tryAcquireShared方法，重写了AQS的该方法，其源码如下：　

protected int tryAcquireShared(int acquires) {
            for (;;) { // 无限循环
                if (hasQueuedPredecessors()) // 同步队列中是否存在其他节点
                    return -1;
                // 获取许可
                int available = getState();
                // 剩余的许可
                int remaining = available - acquires;
                if (remaining < 0 ||
                    compareAndSetState(available, remaining)) // 剩余的许可小于0或者比较设置成功
                    return remaining;
            }
        }

说明：从tryAcquireShared方法的源码可知，它使用公平策略来获取资源，它会判断同步队列中是否存在其他的等待节点。

2.4、构造方法和属性等介绍

    public class Semaphore implements java.io.Serializable {
        // 版本号
        private static final long serialVersionUID = -3222578661600680210L;
        // 属性
        private final Sync sync;
    }
 
    //说明：Semaphore自身只有两个属性，最重要的是sync属性，
    //基于Semaphore对象的操作绝大多数都转移到了对sync的操作。
 
    public Semaphore(int permits) {
        sync = new NonfairSync(permits);
    }
    //说明：该构造函数会创建具有给定的许可数和非公平的公平设置的Semaphore
 
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }
 
    //说明：该构造函数会创建具有给定的许可数和给定的公平设置的Semaphore。

说明：从上面可以看到两个构造方法，都必须提供许可的数量，第二个构造方法可以指定是公平模式还是非公平模式，默认非公平模式。 Semaphore内部基于AQS的共享模式，所以实现都委托给了Sync类。

NonfairSync(int permits) {
     super(permits);
}

可以看到直接调用了父类的构造方法，Sync的构造方法如下：

Sync(int permits) {
     setState(permits);
}

说明：可以看到调用了setState方法，也就是说AQS中的资源就是许可证的数量。

2.5、acquire函数—获取许可

先从获取一个许可看起，并且先看非公平模式下的实现。首先看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;
            }
        }

这里的释放就是对 state 变量减一（或者更多）的。

返回了剩余的 state 大小。

当返回值小于 0 的时候，说明获取锁失败了，那么就需要进入 AQS 的等待队列了。代码如下：

private void doAcquireSharedInterruptibly(int arg)
    throws InterruptedException {
    // 添加一个节点 AQS 队列尾部
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        // 死循环
        for (;;) {
            // 找到新节点的上一个节点
            final Node p = node.predecessor();
            // 如果这个节点是 head，就尝试获取锁
            if (p == head) {
                // 继续尝试获取锁，这个方法是子类实现的
                int r = tryAcquireShared(arg);
                // 如果大于0，说明拿到锁了。
                if (r >= 0) {
                    // 将 node 设置为 head 节点
                    // 如果大于0，就说明还有机会获取锁，那就唤醒后面的线程，称之为传播
                    setHeadAndPropagate(node, r);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
            }
            // 如果他的上一个节点不是 head，就不能获取锁
            // 对节点进行检查和更新状态，如果线程应该阻塞，返回 true。
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 阻塞 park，并返回是否中断，中断则抛出异常
                parkAndCheckInterrupt())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            // 取消节点
            cancelAcquire(node);
    }
}

总的逻辑就是：

  1. 创建一个分享类型的 node 节点包装当前线程追加到 AQS 队列的尾部。
  2. 如果这个节点的上一个节点是 head ，就是尝试获取锁，获取锁的方法就是子类重写的方法。如果获取成功了，就将刚刚的那个节点设置成 head。
  3. 如果没抢到锁，就阻塞等待。

看完了非公平的获取，再看下公平的获取，代码如下：

        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一样首先试一把，说不定就恰好获得了一个许可，这样就可以插队了。
看完了获取许可后，再看一下release()方法。
2.6、release()函数—释放许可

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

    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()方法释放阻塞的线程

private void doReleaseShared() {
    for (;;) {
        Node h = head;
        if (h != null && h != tail) {
            int ws = h.waitStatus;
            if (ws == Node.SIGNAL) {
                // 设置 head 的等待状态为 0 ，并唤醒 head 上的线程
                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
                    continue;            // loop to recheck cases
                unparkSuccessor(h);
            }
            // 成功设置成 0 之后，将 head 状态设置成传播状态
            else if (ws == 0 &&
                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                continue;                // loop on failed CAS
        }
        if (h == head)                   // loop if head changed
            break;
    }
}

说明：该方法的主要作用就是从 AQS 的 head 节点开始唤醒线程，注意，这里唤醒是 head 节点的下一个节点，需要和 doAcquireSharedInterruptibly方法对应，因为 doAcquireSharedInterruptibly 方法唤醒的当前节点的上一个节点，也就是 head 节点。至此，释放 state 变量，唤醒 AQS 头节点结束。

2.7、reducePermits函数—减少许可

 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变量，因为该变量代表许可证的数量。

 2.8、drainPermits函数—耗尽许可

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

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

三、示例
Semaphore代码并没有很复杂，常用的操作就是获取和释放一个许可证，这些操作的实现逻辑也都比较简单，但这并不妨碍Semaphore的广泛应用。下面我们就来利用Semaphore实现客户在银行办理业务的场景示例！

public class BankService {

    public static void main(String[] args) {
        Runnable customer = new Runnable() {
            final Semaphore availableWindow = new Semaphore(5, true);
            int count = 1;
            @Override
            public void run() {
                int time = (int) (Math.random() * 10 + 3);
                int num = count++;
                try {
                    availableWindow.acquire();
                    System.out.println("正在为第【" + num + "】个客户办理业务，需要时间：" + time + "s！");
                    Thread.sleep(time * 1000);
                    if (availableWindow.hasQueuedThreads()) {
                        System.out.println("第【" + num + "】个客户已办理完业务，有请下一位！");
                    } else {
                        System.out.println("第【" + num + "】个客户已办理完业务，没有客户了，休息中！");
                    }
                    availableWindow.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        for (int i = 1; i < 10; i++) {
            new Thread(customer).start();
        }
    }
}

结果示例：

 

 

 

 

 

 

 

 

 

 

 

 

Semaphore原理浅析和相关面试题分析
wojiushimogui的博客
07-07 1128
本文首发在个人公众号：HelloWorldEE，欢迎关注。 本篇文章的来源是这样，有一天，我一同学面试某公司回来，和我分享其被问的相关面试题。其中就有一道关于Semaphore的面试题，个人觉得比较经典，分享出来供大家参考。 具体同学和面试官的对话还原出来是这样。 面试官：现在有一个方法task，希望只能被10个线程调用，利用Java相关类，应该如何来实现？ 同学：使用Java中的Semaphor...
Semaphore 使用&核心原理 图解
架构师尼恩
10-31 810
疯狂创客圈 经典图书 ： 《Netty Zookeeper Redis 高并发实战》 面试必备 + 面试必备 + 面试必备 【博客园总入口 】 疯狂创客圈 经典图书 ： 《SpringCloud、Nginx高并发核心编程》 大厂必备 + 大厂必备 + 大厂必备 【博客园总入口 】 入大厂+涨工资必备： 高并发【 亿级流量IM实战】 实战系列 【 SpringCloud Nginx秒杀】 实战系列 【博客园总入口 】 JUC 高并发工具类 3文章： 1 ..
Java面试实战系列【并发篇】- Semaphore深度解析与实战
最新发布
weixin_53590296的博客
08-15 526
Semaphore是Java并发包中的同步工具，用于控制线程对共享资源的访问数量。其核心原理基于许可证机制，维护一组许可证（permits），线程需先获取许可证才能访问资源，使用完毕后释放。Semaphore支持公平和非公平两种模式，底层通过AQS框架实现同步状态管理。典型应用场景包括数据库连接池、HTTP请求限流等资源受限场景。通过acquire()获取许可证，release()释放，可有效防止系统资源过载。
【并发编程】 — Semaphore原理简介 + 使用方法
01-21
文章目录1 原理简介2 基本使用方法2.1 demo1 — 每次获取一个许可，将线程并发数控制为N个2.2 demo2 — 每次获取多个许可（或者说所有可获取的许可），使线程并发数变为13 其他玩法3.1 demo3 — 尝试获取许可，如果获取不到，直接舍弃 ★★★3.2 demo4 — 尝试一段时间内获取许可，如果获取不到，直接舍弃 ★★★ 源码地址：https://github.com/nieandsun/concurrent-study.git 该工具类，在并发编程中主要用来进行并发控制，或者说限流 1 原理简介 Semaphore是信号的意思,但是我觉得将其理解为许可或者说令
Semaphore实现原理分析
weixin_30266829的博客
09-10 529
synchronized的语义是互斥锁，就是在同一时刻，只有一个线程能获得执行代码的锁。但是现实生活中，有好多的场景，锁不止一把。 比如说，又到了十一假期，买票是重点，必须圈起来。在购票大厅里，有5个售票窗口，也就是说同一时刻可以服务5个人。要实现这种业务需求，用synchronized显然不合适。 查看Java并发工具，发现有一个Semaphore类，天生就是处理这种情况的。 先用Sema...
Semaphore实现原理全面解析
专注Java后端技术干货、项目源码总结分享，期待您的关注。
02-25 1642
Semaphore（信号量）是一个同步工具类，通过Semaphore可以控制同时访问共享资源的线程个数。
深入理解 Semaphore 【源码分析】
weixin_42118323的博客
04-10 1310
Semaphore 是信号量的意思，一般用来控制同时访问某个资源的线程数量，协调各个线程合理的访问公共资源，Semaphore 的底层依赖的是 AQS。Semaphore 使用计数器来控制对共享资源的访问， 如果计数器大于0，则表示允许访问共享资源， 如果为 0，则表示共享资源已经达到访问的上限就拒绝访问， 计数器的计数的就是允许同时访问共享资源的线程数。
Java中的Semaphore：深入理解与应用实践
10-17
本文将详细介绍 Semaphore 的工作原理、使用方法以及如何在实际项目中应用它。 Semaphore 是Java并发编程中实现信号量机制的重要工具。它通过维护一个许可集来控制同时访问特定资源的线程数量，从而避免资源竞争和...
C#线程安全进阶：深入理解Semaphore与Task并发控制的结合
C#作为一门现代化的语言，内置了丰富的并发工具，如Task、Thread、Semaphore等，以支持开发者构建健壮的并发应用。 ## 1.2 线程安全的基本概念 线程安全是指在多线程环境中，代码能够防止多个线程同时访问相同的...
深入理解Java Semaphore：并发控制的关键
Java并发系列中的Semaphore是一种重要的同步工具，它属于Java.util.concurrent（JUC）包下的AQS...通过深入了解其构造器、API以及AQS底层原理，开发者可以更好地在多线程环境中有效地管理和协调资源。
深入浅出java Semaphore.pdf
07-05
《深入浅出Java Semaphore》 Semaphore，中文通常称为信号量，是Java并发编程中的一种重要工具，自JDK 1.5版本起被引入。它主要用于控制对特定资源的并发访问，确保资源得到合理的使用。Semaphore维护了一组虚拟的...
Semaphore原理剖析
大摩羯先生
12-28 536
Semaphore知识总结
Semaphore实现原理
qq_37421368的博客
04-22 500
Semaphore实现原理 Semaphore的acquire 方法 首先定义一个变量，初始化 semaphore 设置凭证为 0 个 public static Semaphore semaphore = new Semaphore(0); 这个方法尝试去获取一个信号量 semaphore.acquire(); 我们看源码实现，可以看到这个方法调用了 sync 的 acquireShare...
Semaphore 基本原理
机械工程跑路哥
08-04 595
Semaphore 信号量是一个计数器，用来限制访问资源的线程的个数；而不是限制的资源的个数；ReentrantLock只允许同一时刻线程的独占，而Semaphore用在共享资源有多个，也允许多个线程来访问这些资源；只是希望对访问的线程上限加以限制；两者底层都基于AQS；1.使用 semaphore限流，访问高峰期时，让超出线程上限的请求线程阻塞，高峰期过去再释放许可；......
【多线程】Semaphore实现原理
阳阳的博客
05-20 1625
前言 Semaphore，信号量，一般用于控制同时访问资源的线程数量。可以认为Synchronized代表的是一把锁，那么Semaphore就是多把锁。 常用方法 public class Semaphore implements java.io.Serializable { //构造方法，传入令牌数，默认实例化一个非公平锁 public Semaphore(int permits); //获取一个令牌，在获取成功之前，以及被其他线程中断之前，当前线程会被阻塞 pub
Semaphore原理解析
m0_38033199的博客
09-06 514
Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。
Semaphore的工作原理及实例
热门推荐
carson0408的博客
03-07 2万+
        Semaphore是一种在多线程环境下使用的设施，该设施负责协调各个线程，以保证它们能够正确、合理的使用公共资源的设施，也是操作系统中用于控制进程同步互斥的量。Semaphore是一种计数信号量，用于管理一组资源，内部是基于AQS的共享模式。它相当于给线程规定一个量从而控制允许活动的线程数。1.工作原理        以一个停车场是运作为例。为了简单起见，假设停车场只有三个车位，一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值