Java并发基础:Semaphore全面解析!

Java并发基础:Semaphore全面解析!_第1张图片

内容概要

Semaphore通过控制许可数量,实现了对并发线程数的精细管理,有效避免了资源竞争和过载问题,能显著提升系统吞吐量和响应速度,同时,Semaphore还支持公平与非公平策略,具有更好的灵活性和适应性,满足了不同业务场景的需求。

核心概念

Semaphorejava.util.concurrent中非常有用的并发编程工具类,它通常被用于限制对某个资源或资源池的并发访问数量。举个实际的例子:假设一个餐厅里只有 10 张桌子,在繁忙的用餐时段,很多顾客会同时来到餐厅,但餐厅的空间有限,不能同时容纳所有顾客,这时,就需要一种机制来控制进入餐厅的顾客数量,确保餐厅不会过于拥挤。

Semaphore 就可以扮演这个控制者的角色,可以将 Semaphore 的许可数设置为 10,这代表着餐厅里最多可以有 10 组顾客同时用餐,每当有顾客进入餐厅并坐下时,Semaphore 的许可数就会减 1;每当有顾客用餐完毕离开时,Semaphore 的许可数就会加 1,如果所有桌子都坐满了,后来的顾客就需要在门外等待,直到有桌子空出来。

在这种业务场景下,使用Semaphore 就可以有效地控制餐厅的拥挤程度,保证了顾客的用餐体验。

具体来说,Semaphore 通常用于以下场景:

  1. 限制并发访问量:当一个系统或应用需要限制对某个共享资源(如数据库连接、文件、网络服务等)的并发访问量时,Semaphore 可以用来控制同时访问这些资源的线程数,通过设置 Semaphore 的许可数,可以确保不会有过多的线程同时访问资源,从而防止资源过载或争用条件导致的性能下降。
  2. 实现线程同步:除了限制并发访问量外,Semaphore 还可以用于协调多个线程的执行顺序,例如,在一个多线程程序中,如果某个操作需要多个线程按照特定的顺序执行,可以使用 Semaphore 来控制这些线程的执行流程。
  3. 资源池管理Semaphore 还可以用于管理资源池,例如连接池、线程池等,通过动态调整 Semaphore 的许可数,可以根据系统的负载情况动态地增加或减少资源的使用量,从而提高系统的伸缩性和资源利用率。

Semaphore 是一种灵活的同步工具,它非常适合在信号量场景中控制对资源的访问,能够在多线程环境中提供细粒度的控制,帮助开发者有效地管理系统资源,比如,用来控制对数据库连接、线程池资源或其他共享资源的并发访问,从而避免资源争用和系统过载,保证系统的稳定性和性能。

代码案例

下面是一个简单的Java代码示例,演示了如何使用Semaphore来限制对一组资源的并发访问,如下代码:

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.Semaphore;  
  
public class SemaphoreExample {  
  
    // 创建一个Semaphore,初始许可为3,表示资源池中最多有3个资源可用  
    private static final Semaphore semaphore = new Semaphore(3);  
  
    public static void main(String[] args) {  
        // 创建一个固定大小的线程池来模拟客户端请求  
        ExecutorService executor = Executors.newFixedThreadPool(5);  
  
        // 提交10个任务到线程池,每个任务代表一个客户端请求  
        for (int i = 0; i < 10; i++) {  
            executor.submit(() -> {  
                try {  
                    // 线程尝试获取许可  
                    semaphore.acquire();  
                    System.out.println("线程" + Thread.currentThread().getName() + "获取到资源,开始处理...");  
  
                    // 模拟资源处理时间  
                    Thread.sleep((long) (Math.random() * 1000));  
  
                    System.out.println("线程" + Thread.currentThread().getName() + "处理完毕,释放资源...");  
  
                    // 线程释放许可  
                    semaphore.release();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
            });  
        }  
  
        // 关闭线程池  
        executor.shutdown();  
    }  
}

在上面代码中,创建了一个Semaphore实例,初始许可设置为3,这意味着最多只能有3个线程同时访问资源,然后创建了一个固定大小为5的线程池来模拟客户端请求,提交了10个任务到线程池,每个任务都尝试获取Semaphore的许可,模拟资源的访问。

当线程调用semaphore.acquire()时,它会尝试获取一个许可,如果许可可用,线程将继续执行;如果没有许可可用,线程将被阻塞,直到有许可可用。当线程完成资源访问后,它调用semaphore.release()来释放许可,这样其他等待的线程就可以获取许可并访问资源了。

如下输出结果:

线程pool-1-thread-1获取到资源,开始处理...  
线程pool-1-thread-2获取到资源,开始处理...  
线程pool-1-thread-3获取到资源,开始处理...  
线程pool-1-thread-3处理完毕,释放资源...  
线程pool-1-thread-1处理完毕,释放资源...  
线程pool-1-thread-4获取到资源,开始处理...  
线程pool-1-thread-2处理完毕,释放资源...  
线程pool-1-thread-5获取到资源,开始处理...  
线程pool-1-thread-4处理完毕,释放资源...  
线程pool-1-thread-5处理完毕,释放资源...  
线程pool-1-thread-3获取到资源,开始处理...  
线程pool-1-thread-3处理完毕,释放资源...

从输出中可以看到,尽管有一个大小为5的线程池,但Semaphore确保了同时访问资源的线程数不超过3个,当线程处理完资源后,它会释放许可,允许其他线程获取许可并继续执行。

核心API

下面是 Semaphore 类中一些重要方法的解释:

acquire()

此方法用于获取一个许可,如果当前没有可用的许可,则当前线程会被阻塞,直到有许可可用,这是 Semaphore 最基本的使用方式,用于控制对资源的访问。

acquire(int permits)

这个方法允许一次性获取多个许可,如果当前可用许可数量少于请求的数量,则线程会被阻塞,直到有足够的许可可用。

acquireUninterruptibly()

acquireUninterruptibly()acquireUninterruptibly(int permits)这两个方法与 acquire 类似,但区别在于它们不会响应中断,即使其他线程中断了正在等待的线程,这些线程也会继续等待,直到获得许可。

tryAcquire

tryAcquire()tryAcquire(int permits)这两个方法尝试获取一个或多个许可,如果当前有可用的许可则立即返回 true,并且获取成功;如果没有可用许可则立即返回 false,线程不会被阻塞。

tryAcquire(long timeout, TimeUnit unit)

tryAcquire(long timeout, TimeUnit unit)和tryAcquire(int permits, long timeout, TimeUnit unit)这两个方法尝试在给定的时间内获取一个或多个许可,如果在指定的时间内获得了许可,则返回 true;否则,返回 false,如果线程在等待期间被中断,那么这两个方法都会抛出 InterruptedException

release

release()此方法用于释放一个许可,将其返回给 Semaphore,这样其他等待的线程就可以获取它,通常在完成对资源的访问后调用此方法。

release(int permits)

release(int permits)这个方法允许一次性释放多个许可。

availablePermits

availablePermits()这个方法返回当前 Semaphore 中可用的许可数量。

hasQueuedThreads()

检查是否有任何线程正在等待获取许可。

getQueueLength()

返回正在等待获取许可的线程数。

drainPermits()

此方法返回并删除当前所有可用的许可,主要用于一些特殊的场景,比如需要在某个时刻一次性消耗所有许可。

reducePermits(int reduction)

这个方法用于减少 Semaphore 中的可用许可数量,通常用于一些动态调整资源池大小的场景,需要注意的是,这个方法不会阻塞,如果减少后的许可数小于0,那么会抛出 IllegalArgumentException

注意:Semaphore 并不保证获取许可的公平性,即等待时间最长的线程不一定会优先获得许可。

核心总结

Java并发基础:Semaphore全面解析!_第2张图片

优点

  1. 简单易用:通过许可数量,轻松控制并发线程数。
  2. 高效:避免了不必要的线程创建和销毁,提高了系统吞吐量。
  3. 灵活:支持公平和非公平策略,可根据需求选择。

缺点

  1. 不保证公平性:默认策略下,先到的线程不一定先获得许可。
  2. 可能导致死锁:使用不当(如在持有Semaphore时执行其他阻塞操作)时,可能会引发死锁。

Java并发基础:Semaphore全面解析!_第3张图片

END!

你可能感兴趣的:(Java并发基础,java,数据库,网络)