什么是Java 中的 Semaphore？

最新推荐文章于 2024-07-11 17:24:34 发布
最新推荐文章于 2024-07-11 17:24:34 发布
阅读量604 收藏 26
点赞数 19
分类专栏： Java面试题 文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139399175
版权

在多线程编程中，如何有效地控制多个线程对共享资源的访问是一个重要的问题。Semaphore（信号量）是 Java 中一个重要的同步工具，用于控制同时访问特定资源的线程数量。本文将深入探讨 Semaphore 的产生背景、基本使用、工作原理及其广泛的应用场景。

Semaphore 产生的背景

Semaphore 的概念由荷兰计算机科学家 Edsger W. Dijkstra 在 1960 年代提出，旨在解决多线程编程中的同步问题，即如何在多个线程或进程之间协调对共享资源的访问。

多线程同步问题

在多线程环境中，多个线程可能会同时访问共享资源，这会导致数据不一致或竞态条件。常见的同步问题包括：

  1. 互斥访问：确保同一时刻只有一个线程可以访问共享资源。
  2. 读写锁：允许多个线程同时读取资源，但写入资源时需要独占访问。
  3. 信号量控制：限制并发访问的线程数，避免资源过载。

早期解决方案

在 Semaphore 被提出之前，早期的解决方案主要依赖于锁（Lock）和条件变量（Condition Variable）。这些同步原语可以解决基本的互斥访问问题，但在控制并发线程数量方面存在一定的局限性。

信号量的引入

为了解决上述问题，Dijkstra 引入了信号量的概念。信号量是一种计数器，用于控制对共享资源的访问。信号量可以是二进制信号量（类似于互斥锁）或计数信号量（允许多个线程同时访问资源）。

信号量的基本操作包括：

  • P 操作（Proberen，试图减少）：尝试减少信号量，如果信号量为 0，则线程进入等待状态。
  • V 操作（Verhogen，增加）：增加信号量，并唤醒等待队列中的一个线程。

信号量的实现

在 Java 中，信号量通过 Semaphore 类实现。Semaphore 提供了获取和释放许可的方法，用于控制线程对共享资源的并发访问。

现代应用

在现代计算机系统中，Semaphore 的应用场景非常广泛，包括但不限于：

  1. 限流控制：限制同时访问某个服务或资源的线程数。
  2. 资源池管理：控制对有限资源（如数据库连接、线程池）的并发访问。
  3. 生产者-消费者模型：协调生产者和消费者线程之间的数据传递。
  4. 并发任务执行：限制同时执行的并发任务数量，避免系统过载。

Semaphore 的基本使用

假设有 N (N>5) 个线程需要访问一个共享资源，但同一时刻只能有 5 个线程能够访问这个资源。以下是一个简单的示例：

java

import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    public static void main(String[] args) {
        // 初始共享资源数量
        final Semaphore semaphore = new Semaphore(5);

        // 模拟 N 个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new Task(semaphore)).start();
        }
    }

    static class Task implements Runnable {
        private Semaphore semaphore;

        Task(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                // 获取1个许可
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName() + " 获取了许可");
                // 模拟任务执行
                Thread.sleep(2000);
                // 释放1个许可
                semaphore.release();
                System.out.println(Thread.currentThread().getName() + " 释放了许可");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个示例中，同一时刻最多只有 5 个线程能够获取到许可并执行任务，其他线程会被阻塞，直到有线程释放许可。

Semaphore 的构造方法

Semaphore 有两个构造方法：

java

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

public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
  • permits：表示许可的数量。
  • fair：表示是否是公平模式。

公平模式下，调用 acquire() 方法的顺序就是获取许可的顺序，遵循 FIFO；非公平模式下则是抢占式的。

Semaphore 的工作原理

Semaphore 是共享锁的一种实现，其核心在于内部的 state 值，这个值表示当前剩余的许可数量。以下是 acquire 和 release 方法的源码解析：

acquire 方法

java

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

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}
  • acquire() 方法尝试获取一个许可（arg=1）。
  • tryAcquireShared(arg) 方法尝试减少 state 的值，如果 state >= arg 则表示获取成功，否则线程会被阻塞。

tryAcquireShared 方法

java

protected int tryAcquireShared(int arg) {
    for (;;) {
        int available = getState();
        int remaining = available - arg;
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;
    }
}
  • getState() 获取当前剩余的许可数量。
  • compareAndSetState(available, remaining) 使用 CAS 操作尝试修改 state 的值。

release 方法

java

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

public final boolean releaseShared(int arg) {
    if (tryReleaseShared(arg)) {
        doReleaseShared();
        return true;
    }
    return false;
}
  • release() 方法尝试释放一个许可（arg=1）。
  • tryReleaseShared(arg) 方法增加 state 的值，并唤醒同步队列中的一个线程。

tryReleaseShared 方法

java

protected boolean tryReleaseShared(int arg) {
    for (;;) {
        int current = getState();
        int next = current + arg;
        if (compareAndSetState(current, next))
            return true;
    }
}
  • getState() 获取当前剩余的许可数量。
  • compareAndSetState(current, next) 使用 CAS 操作尝试修改 state 的值。

Semaphore 的应用场景

1. 限流控制

场景描述

在高并发系统中，限流控制是非常重要的一环。限流可以保护系统避免因瞬时高并发请求导致的过载，从而提高系统的稳定性。

示例代码

假设我们有一个 Web 服务，最多允许 10 个并发请求。使用 Semaphore 来实现限流控制：

java

import java.util.concurrent.Semaphore;

public class WebService {
    // 定义一个信号量，初始许可数量为10
    private final Semaphore semaphore = new Semaphore(10);

    public void handleRequest(String request) {
        try {
            // 获取一个许可，如果没有许可则会阻塞等待
            semaphore.acquire();
            System.out.println("Handling request: " + request);
            // 模拟处理请求
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放一个许可
            semaphore.release();
        }
    }

    public static void main(String[] args) {
        WebService service = new WebService();

        // 模拟20个请求
        for (int i = 0; i < 20; i++) {
            final int requestId = i;
            new Thread(() -> service.handleRequest("Request " + requestId)).start();
        }
    }
}

在这个示例中，我们定义了一个 Semaphore，初始许可数量为 10。每次处理请求时，先获取一个许可，如果没有许可则会阻塞等待。处理完请求后，释放一个许可。通过这种方式，我们可以有效地控制并发请求的数量，避免系统过载。

2. 资源池管理

场景描述

在资源有限的情况下，比如数据库连接池、线程池等，需要控制对这些有限资源的并发访问。Semaphore 可以很好地管理这些资源的分配。

示例代码

假设我们有一个数据库连接池，最多允许 5 个并发连接：

java

import java.util.concurrent.Semaphore;

public class ConnectionPool {
    private final Semaphore semaphore = new Semaphore(5);

    public void getConnection() {
        try {
            // 获取一个许可，如果没有许可则会阻塞等待
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + " 获取了数据库连接");
            // 模拟使用数据库连接
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放一个许可
            semaphore.release();
            System.out.println(Thread.currentThread().getName() + " 释放了数据库连接");
        }
    }

    public static void main(String[] args) {
        ConnectionPool pool = new ConnectionPool();

        // 模拟10个线程获取数据库连接
        for (int i = 0; i < 10; i++) {
            new Thread(pool::getConnection).start();
        }
    }
}

在这个示例中，我们定义了一个 Semaphore，初始许可数量为 5。每次获取数据库连接时，先获取一个许可，如果没有许可则会阻塞等待。使用完数据库连接后，释放一个许可。通过这种方式，我们可以有效地管理数据库连接的分配。

3. 生产者-消费者模型

场景描述

生产者-消费者模型是一种经典的多线程协作模型。生产者负责生产数据，消费者负责消费数据。使用 Semaphore 可以很好地协调生产者和消费者之间的数据传递。

示例代码

假设我们有一个生产者-消费者模型，生产者生产数据，消费者消费数据：

java

import java.util.concurrent.Semaphore;
import java.util.Queue;
import java.util.LinkedList;

public class ProducerConsumer {
    private final Semaphore items = new Semaphore(0); // 表示可消费的项目数量
    private final Semaphore spaces = new Semaphore(10); // 表示可生产的空间数量
    private final Queue<Integer> queue = new LinkedList<>();

    public void produce(int item) throws InterruptedException {
        spaces.acquire(); // 获取一个生产许可
        synchronized (this) {
            queue.add(item);
            System.out.println("Produced: " + item);
        }
        items.release(); // 释放一个消费许可
    }

    public int consume() throws InterruptedException {
        items.acquire(); // 获取一个消费许可
        int item;
        synchronized (this) {
            item = queue.poll();
            System.out.println("Consumed: " + item);
        }
        spaces.release(); // 释放一个生产许可
        return item;
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // 创建生产者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.produce(i);
                    Thread.sleep(100);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();

        // 创建消费者线程
        new Thread(() -> {
            try {
                for (int i = 0; i < 20; i++) {
                    pc.consume();
                    Thread.sleep(200);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

在这个示例中，我们定义了两个 Semaphore：

  • items：表示可消费的项目数量，初始值为 0。
  • spaces：表示可生产的空间数量，初始值为 10。

生产者线程在生产数据时，先获取一个生产许可，生产完数据后，释放一个消费许可。消费者线程在消费数据时，先获取一个消费许可，消费完数据后，释放一个生产许可。通过这种方式，我们可以有效地协调生产者和消费者之间的数据传递。

4. 并发任务执行

场景描述

在一些任务调度系统中，可能需要限制同时执行的并发任务数量，以避免系统过载。Semaphore 可以很好地控制并发任务的执行数量。

示例代码

假设我们有一个任务调度系统，最多允许 3 个并发任务：

java

import java.util.concurrent.Semaphore;

public class TaskScheduler {
    private final Semaphore semaphore = new Semaphore(3);

    public void executeTask(String task) {
        try {
            semaphore.acquire(); // 获取一个许可，如果没有许可则会阻塞等待
            System.out.println("Executing task: " + task);
            // 模拟执行任务
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            semaphore.release(); // 释放一个许可
        }
    }

    public static void main(String[] args) {
        TaskScheduler scheduler = new TaskScheduler();

        // 模拟10个任务
        for (int i = 0; i < 10; i++) {
            final int taskId = i;
            new Thread(() -> scheduler.executeTask("Task " + taskId)).start();
        }
    }
}

在这个示例中，我们定义了一个 Semaphore，初始许可数量为 3。每次执行任务时，先获取一个许可，如果没有许可则会阻塞等待。任务执行完毕后，释放一个许可。通过这种方式，我们可以有效地控制并发任务的执行数量。

结论

通过本文的讲解，我们深入了解了 Semaphore 的产生背景、基本使用、构造方法、工作原理以及其典型的应用场景。Semaphore 是一个非常强大的工具，可以很好地控制资源的并发访问，适用于多种实际应用场景，如限流控制、资源池管理、生产者-消费者模型和并发任务执行等。在实际开发中，合理使用 Semaphore 可以极大地提高系统的稳定性和并发处理能力，是多线程编程中不可或缺的工具之一。

qq_33326733
关注
  • 19
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中Semaphore(信号量)的使用方法
08-25
Java中Semaphore（信号量）的使用方法 Semaphore（信号量）是一种非常重要的并发访问控制机制，它可以用来保护一个或者多个共享资源的访问。Semaphore内部维护了一个计数器，其值为可以访问的共享资源的个数。一个...
Java基于Semaphore构建阻塞对象池
08-19
在Java并发编程中，Semaphore是一种重要的同步工具类，它提供了对有限资源的访问控制，能够有效地管理和限制同时访问特定资源的线程数量。Semaphore在Java 5中被引入，是java.util.concurrent包的一部分，它是基于...
Semaphore是什么？
披甲上战场的博客
07-04 3490
Semaphore简介 semaphore英文翻译为信号标，它是能控制允许多少线程去访问资源，也可以反馈线程在指定时间是否获得可执行权的信号，从而对这些超时未获取权力的线程做另行安排。 Semaphore使用场景 从简介中可以得知，semaphore可以限制并发访问数量，即为限流，像是微服务组件hystrix、sentinel等限流中间件都可使用此原理，当然随之而来，那些被限制通行的线程是被丢弃？还是去执行另外的流程，就是“降级服务”。 Semaphore使用demo 1、定义线程任务+降级服务
Java中的Semaphore是什么
渡安H的博客
11-13 414
Java中的Semaphore是一种新的同步类，它是一个计数信号。 从概念上讲，从概念上讲，信号量维护了一个许可集合。 如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。 每个 release()添加一个许可，从而可能释放一个正在阻塞的获取者。 但是，不使用实际的许可对象，Semaphore只对可用许可的号码进行计数，并采取相应的行动。 信号量常常用于多线程的代码...
Java中的信号量Semaphore
tanxinji的博客
06-20 423
 信号量机制可以用来保证线程互斥  创建Semaphore对象: 传入一个整形参数，类似于公共资源  常用方法:  acquire();获取一个公共资源，公共资源-1，如果公共资源
Java并发 - Semaphore 详解
--土拨鼠--
01-29 1054
Semaphore 的类结构与ReentrantLock 的类结构相同，类内部总共存在Sync、NonfairSync、FairSync三个静态内部类。Sync类继承AbstactQueuedSynchronizer。NotfairSync和FairSync继承Sync。
Java中的Semaphore类最全讲义
07-24
1.2 Semaphore概述 Semaphore的基本用法 2.1 创建Semaphore对象 2.2 acquire()方法 2.3 release()方法 控制资源访问数量 3.1 场景介绍 3.2 使用Semaphore控制资源访问 实现有界资源池 4.1 场景介绍 4.2 使用...
Java 信号量Semaphore的实现
08-25
Java 信号量Semaphore是Java并发编程中的一种机制，用于控制多个线程的并发执行。Semaphore的实现主要是通过计数器来实现的，每个Semaphore对象都维护着一个计数器，用于记录当前可用的许可证数量。 在Java中，...
java线程并发semaphore类示例
09-04
在Java中，Semaphore类提供了对并发线程进行计数的许可管理，允许我们限制同时访问特定资源的线程数量。这在处理并发任务时非常有用，例如限制数据库连接池的大小、限制同时访问硬件设备的数量或者限制某个服务的...
配置Java开发环境
Broken_x的博客
07-10 1081
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 359
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1196
在 Java 中，可以通过多种方法将一个Object转换为Integer。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1830
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java占位符替换五种方式
weixin_61478518的博客
07-08 427
在业务开发中，经常需要输出文本串。其中，部分场景下大部分文本内容是一样的，只有少部分点是不一样。简单做法是直接拼接字段，但是这会有个问题。后面如果想要修改内容，那么每个地方都要修改，这不符合设计模式中的开闭原则，面向应该对扩展开放，对修改关闭。如何解决这个问题？先来看现实生活中的例子，个人信息填写。一般会要填写表格，已经定义好了姓名，性别，年龄等字段，只要填写对应的个人信息就好了。在程序开发中，我们会预先定义好一个字符串模板，需要改动的点使用占位符。
Java方法练习-双色球彩票系统
最新发布
T1798218285的博客
07-11 101
红色球号码从1-33中选择；蓝色球号码从1-16中选择。投注号码由6个红色球号码和1个蓝色球号码组成。三等奖 5+1 / 5+0 3000。四等奖4+1 / 4+0 200。六等奖1+1 / 1+0 5。一等奖6+1 1000w。二等奖6+0 500w。五等奖3+1 / 2+1。
AI技术的转变：从辨别式到生成式
学IT，找陈寒
07-09 3059
李彦宏在2024世界人工智能大会上的发言，提醒我们在AI技术发展的道路上，不要盲目追求技术本身或表面的用户数据，而应更多地关注技术的实际应用和产业价值。在大模型技术与个性化应用之间找到平衡，将是未来发展的关键。作为AI从业者和技术爱好者，我们应以务实的态度，探索AI技术在各个领域的实际应用，为产业发展和社会进步贡献力量。通过李彦宏的发言，我深刻认识到AI技术发展的方向和挑战，也更加坚定了自己在这一领域继续探索和创新的信心。未来，愿我们共同努力，推动AI技术更好地服务于社会和产业，为人类创造更美好的未来。
java中 使用数组实现需求小案例（二）
qq_44304677的博客
07-09 822
java小案例，数组需求实现，使用Random函数实现用户输入随机数生成一个打乱的数组
JavaSE 面向对象程序设计进阶 IO流 字节流详解 抛出异常
牛马程序员的博客
07-10 646
存储和读取数据的解决方案内存中数据不能永久化存储 程序停止运行 数据消失File只能对文件本身进行操作 不能读写文件里存储的数据读写数据必须要有IO流可以把程序中的数据保存到文件当中还可以把本地文件中的数据读取到数据当中。
java中Semaphore的介绍，以及使用
07-12
Semaphore 是 Java 中的一个同步工具类，用于控制同时访问某个资源的线程数量。它维护了一组许可证，每个许可证都表示一个线程可以访问共享资源的权限。Semaphore 通过 acquire() 方法获取许可证，release() 方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值