深入解析Java并发包(JUC)中的Semaphore

本文涉及的产品
全局流量管理 GTM,标准版 1个月
云解析 DNS,旗舰版 1个月
公共DNS(含HTTPDNS解析),每月1000万次HTTP解析
简介: 深入解析Java并发包(JUC)中的Semaphore

一、Semaphore简介

Semaphore,即信号量,是操作系统中的一个经典概念。在Java并发包(java.util.concurrent,简称JUC)中,Semaphore类实现了这一概念,用于控制同时访问特定资源的线程数量。与synchronized关键字和ReentrantLock类不同,Semaphore可以实现更为复杂的线程同步需求,允许一定数量的线程同时访问共享资源。


二、Semaphore的工作原理

Semaphore内部维护了一组许可证(permits)。每个线程在访问共享资源之前,必须先获取一个许可证。如果许可证不足,则线程将被阻塞,直到有许可证可用。当线程释放资源时,它会归还一个许可证,从而允许其他等待的线程获取资源。

通过控制许可证的数量,Semaphore可以实现对共享资源访问的精细控制。例如,如果有一个需要限制并发访问次数的资源池,就可以使用Semaphore来实现。

三、Semaphore的特性

  1. 公平性Semaphore可以配置为公平的或非公平的。公平的Semaphore将按照线程请求许可证的顺序来分配它们,而非公平的Semaphore则不保证这种顺序。
  2. 可重用性:与CountDownLatch等一次性使用的同步工具不同,Semaphore可以多次使用。一旦线程释放了许可证,其他线程就可以再次获取它。
  3. 资源池控制:通过调整许可证的数量,Semaphore可以灵活地控制对资源池的并发访问。这对于保护有限资源或实现流量控制非常有用。

四、Semaphore源码分析

首先,Semaphore类中的主要组成部分是一个继承自AbstractQueuedSynchronizer(AQS)的内部类Sync。AbstractQueuedSynchronizer是Java并发包中提供的一个用于构建锁和其他同步组件的基础框架。

public class Semaphore implements java.io.Serializable {
    // 当前的许可数
    private final Sync sync;

    // 构造函数,创建一个具有给定许可数的Semaphore,默认非公平策略
    public Semaphore(int permits) {
        sync = new Sync(permits);
    }

    // 构造函数,创建一个具有给定许可数的Semaphore,并指定公平策略
    public Semaphore(int permits, boolean fair) {
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

    // 获取一个许可,如果当前没有可用许可,则等待
    public void acquire() throws InterruptedException {
        sync.acquireSharedInterruptibly(1);
    }

    // 释放一个许可
    public void release() {
        sync.releaseShared(1);
    }

    // ... 其他方法,如acquire(int), release(int), tryAcquire(), tryRelease(), drainPermits()等

    // 同步器抽象类
    abstract static class Sync extends AbstractQueuedSynchronizer {
        // 返回当前许可数
        final int getPermits() {
            return getState();
        }

        // ... 其他方法,如tryAcquireShared(), tryReleaseShared()等

        // 提供给子类实现的公平锁和非公平锁
        // 这些方法需要由子类根据公平策略来实现
        protected abstract boolean tryAcquireShared(int acquires);
        protected abstract boolean tryReleaseShared(int releases);

        // 减少许可数
        final void reducePermits(int reductions) {
            // ... 实现细节
        }

        // ... 其他方法
    }

    // 非公平同步器
    static final class NonfairSync extends Sync {
        // ... 实现tryAcquireShared()等方法
    }

    // 公平同步器
    static final class FairSync extends Sync {
        // ... 实现tryAcquireShared()等方法,保证FIFO顺序
    }
}

源码解读:


状态管理:Semaphore使用AQS的同步状态来管理许可的数量。在Semaphore中,同步状态表示当前可用的许可数。getState()方法返回当前的许可数。


许可的获取与释放:当线程调用acquire()方法时,它会尝试通过Sync的acquireSharedInterruptibly()方法获取一个许可。如果当前没有可用许可,线程将被阻塞。类似地,当线程调用release()方法时,它会通过Sync的releaseShared()方法释放一个许可,这可能会唤醒正在等待的线程。


公平性:Semaphore可以在创建时指定为公平或非公平。公平Semaphore确保等待时间最长的线程优先获得许可,而非公平Semaphore则不保证等待线程的获取顺序。这是通过FairSync和NonfairSync两个内部类来实现的,它们分别实现了tryAcquireShared()和tryReleaseShared()方法以提供不同的获取和释放策略。


等待队列:AQS维护了一个等待队列,用于管理等待获取许可的线程。当线程尝试获取许可但失败时(即许可不足),它将被添加到等待队列中。当其他线程释放许可时,等待队列中的线程可能会被唤醒并尝试再次获取许可。这个过程是由AQS的内部机制自动管理的。


自定义同步器:Semaphore通过扩展AQS并实现必要的方法来定义自己的同步语义。这包括实现tryAcquireShared()和tryReleaseShared()等方法,这些方法根据Semaphore的当前状态和公平性策略来决定是否允许线程获取或释放许可。

五、Semaphore的主要方法

Semaphore类提供了几个主要的方法来操作许可证:

  1. acquire(): 获取一个许可证。如果当前没有可用的许可证,则线程将被阻塞,直到有许可证可用。
  2. release(): 释放一个许可证。这将增加可用许可证的数量,并可能唤醒正在等待的线程。
  3. acquire(int permits): 获取指定数量的许可证。如果当前没有足够的许可证,则线程将被阻塞。
  4. release(int permits): 释放指定数量的许可证。

此外,Semaphore还提供了带有超时参数的acquire方法,允许线程在等待指定时间后放弃获取许可证。

六、Semaphore实现控制资源的访问

我们使用Semaphore来控制对资源访问,代码如下:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    // 定义一个Semaphore,初始许可数为3
    private static final Semaphore semaphore = new Semaphore(3);

    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(5);

        // 模拟5个线程尝试访问一个只允许3个并发访问的资源
        for (int i = 0; i < 5; i++) {
            final int threadId = i;
            executor.execute(() -> {
                try {
                    // 获取一个许可
                    semaphore.acquire();
                    accessResource(threadId);
                    // 访问完成后释放许可
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }

        // 关闭线程池(这在实际应用中通常会在所有任务完成后进行)
        // executor.shutdown();
    }

    // 模拟访问资源的方法
    private static void accessResource(int threadId) throws InterruptedException {
        System.out.println("线程 " + threadId + " 获取到许可,开始访问资源。");
        // 模拟资源访问时间
        Thread.sleep(1000);
        System.out.println("线程 " + threadId + " 访问资源结束,释放许可。");
    }
}

代码解释:

  1. 我们首先定义了一个Semaphore对象,其初始许可数设置为3。这意味着最多允许3个线程同时访问某个资源。
  2. 然后,我们创建了一个固定大小为5的线程池,用于模拟5个线程尝试并发访问资源。
  3. 在循环中,我们为每个线程提交了一个任务到线程池。每个任务首先尝试通过调用semaphore.acquire()来获取一个许可。如果许可可用,线程将继续执行并访问资源;如果许可不可用(即已达到最大并发数),线程将被阻塞,直到有许可可用。
  4. accessResource方法中,我们模拟了线程访问资源的过程,通过Thread.sleep(1000)来模拟资源访问所需的时间。
  5. 访问资源完成后,线程通过调用semaphore.release()来释放许可,这样其他等待的线程就有机会获取许可并访问资源。

七、适用场景

Semaphore适用于以下场景:

  1. 保护有限资源:当需要限制对某个资源池的并发访问次数时,可以使用Semaphore。例如,数据库连接池或线程池。
  2. 流量控制:在需要限制对某个服务的并发请求数时,可以使用Semaphore作为限流器。这可以防止系统过载并保持稳定的性能。
  3. 实现复杂的同步模式:与其他同步工具结合使用,Semaphore可以实现更复杂的线程同步模式,如读写锁等。

总之,Semaphore是Java并发编程中一个强大而灵活的同步工具。通过掌握其工作原理和特性,开发人员可以更好地应对多线程环境中的并发挑战。

相关文章
|
11天前
|
存储 Java 计算机视觉
Java二维数组的使用技巧与实例解析
本文详细介绍了Java中二维数组的使用方法
28 15
|
11天前
|
算法 搜索推荐 Java
【潜意识Java】深度解析黑马项目《苍穹外卖》与蓝桥杯算法的结合问题
本文探讨了如何将算法学习与实际项目相结合,以提升编程竞赛中的解题能力。通过《苍穹外卖》项目,介绍了订单配送路径规划(基于动态规划解决旅行商问题)和商品推荐系统(基于贪心算法)。这些实例不仅展示了算法在实际业务中的应用,还帮助读者更好地准备蓝桥杯等编程竞赛。结合具体代码实现和解析,文章详细说明了如何运用算法优化项目功能,提高解决问题的能力。
44 6
|
11天前
|
存储 算法 搜索推荐
【潜意识Java】期末考试可能考的高质量大题及答案解析
Java 期末考试大题整理:设计一个学生信息管理系统,涵盖面向对象编程、集合类、文件操作、异常处理和多线程等知识点。系统功能包括添加、查询、删除、显示所有学生信息、按成绩排序及文件存储。通过本题,考生可以巩固 Java 基础知识并掌握综合应用技能。代码解析详细,适合复习备考。
16 4
|
17天前
|
SQL Java 数据库连接
如何在 Java 代码中使用 JSqlParser 解析复杂的 SQL 语句?
大家好,我是 V 哥。JSqlParser 是一个用于解析 SQL 语句的 Java 库,可将 SQL 解析为 Java 对象树,支持多种 SQL 类型(如 `SELECT`、`INSERT` 等)。它适用于 SQL 分析、修改、生成和验证等场景。通过 Maven 或 Gradle 安装后,可以方便地在 Java 代码中使用。
137 11
|
11天前
|
存储 Java
【潜意识Java】期末考试可能考的选择题(附带答案解析)
本文整理了 Java 期末考试中常见的选择题,涵盖数据类型、控制结构、面向对象编程、集合框架、异常处理、方法、流程控制和字符串等知识点。每道题目附有详细解析,帮助考生巩固基础,加深理解。通过这些练习,考生可以更好地准备考试,掌握 Java 的核心概念和语法。
17 1
|
16天前
|
存储 分布式计算 Hadoop
基于Java的Hadoop文件处理系统:高效分布式数据解析与存储
本文介绍了如何借鉴Hadoop的设计思想,使用Java实现其核心功能MapReduce,解决海量数据处理问题。通过类比图书馆管理系统,详细解释了Hadoop的两大组件:HDFS(分布式文件系统)和MapReduce(分布式计算模型)。具体实现了单词统计任务,并扩展支持CSV和JSON格式的数据解析。为了提升性能,引入了Combiner减少中间数据传输,以及自定义Partitioner解决数据倾斜问题。最后总结了Hadoop在大数据处理中的重要性,鼓励Java开发者学习Hadoop以拓展技术边界。
37 7
|
11天前
|
Java 编译器 程序员
【潜意识Java】期末考试可能考的简答题及答案解析
为了帮助同学们更好地准备 Java 期末考试,本文列举了一些常见的简答题,并附上详细的答案解析。内容包括类与对象的区别、多态的实现、异常处理、接口与抽象类的区别以及垃圾回收机制。通过这些题目,同学们可以深入理解 Java 的核心概念,从而在考试中更加得心应手。每道题都配有代码示例和详细解释,帮助大家巩固知识点。希望这些内容能助力大家顺利通过考试!
11 0
|
2月前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性,极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理,并通过Java代码手写模拟Spring Boot的启动过程,特别是spring.factories文件的解析源码API机制。
120 2
|
1月前
|
设计模式 存储 安全
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析
创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是"将对象的创建与使用分离”。这样可以降低系统的耦合度,使用者不需要关注对象的创建细节。创建型模式分为5种:单例模式、工厂方法模式抽象工厂式、原型模式、建造者模式。
【23种设计模式·全精解析 | 创建型模式篇】5种创建型模式的结构概述、实现、优缺点、扩展、使用场景、源码解析
|
1月前
|
存储 设计模式 算法
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析
行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为模式具有更大的灵活性。 行为型模式分为: • 模板方法模式 • 策略模式 • 命令模式 • 职责链模式 • 状态模式 • 观察者模式 • 中介者模式 • 迭代器模式 • 访问者模式 • 备忘录模式 • 解释器模式
【23种设计模式·全精解析 | 行为型模式篇】11种行为型模式的结构概述、案例实现、优缺点、扩展对比、使用场景、源码解析

推荐镜像

更多