Java并发神器Semaphore全方位解析

最新推荐文章于 2025-07-24 08:30:00 发布
原创 最新推荐文章于 2025-07-24 08:30:00 发布 · 4.9k 阅读 · 31 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言 #maven #spring boot #spring cloud #mybatis

在现代的Java开发中，高并发已经成为了一个不可忽视的话题。而在众多的并发工具中，Semaphore 可以说是一个既强大又灵活的工具。今天，我们就来深入探讨一下 Semaphore 的底层原理、实现机制、实际应用场景以及项目实战代码。准备好了吗？让我们开始这场并发之旅吧！

2024最全大厂面试题无需C币点我下载或者在网页打开全套面试题已打包

AI绘画关于SD,MJ,GPT,SDXL,Comfyui百科全书

1. Semaphore是什么？

Semaphore（信号量）是一个用于控制同时访问特定资源的线程数量的同步工具。它通过维护一个许可集来管理对资源的访问。线程在访问资源之前必须从信号量中获取许可，访问完成后释放许可。如果没有可用的许可，线程将被阻塞，直到有可用的许可为止。

1.1 Semaphore的基本用法

在Java中，Semaphore 类位于 java.util.concurrent 包中。它的构造方法主要有以下两种：

  1. Semaphore(int permits)：创建一个具有指定许可数的 Semaphore。
  2. Semaphore(int permits, boolean fair)：创建一个具有指定许可数且具有公平性选择的 Semaphore。
  • 公平性：如果公平性设为 true，则线程将按先来先得的顺序获取许可。
Semaphore semaphore = new Semaphore(3); // 创建一个具有3个许可的信号量

2. Semaphore底层原理

2.1 基本原理

Semaphore 的核心在于许可的管理，许可表示资源的访问权限。每个信号量维护一个内部计数器，该计数器表示当前可用的许可数量。

  • 当线程调用 acquire() 方法时，如果计数器大于0，则减1并继续执行；如果计数器为0，则线程进入等待状态，直到有其他线程释放许可。
  • 当线程调用 release() 方法时，计数器加1，如果有等待的线程，则唤醒其中一个。

2.2 主要方法

  • acquire()：获取一个许可，如果没有可用许可，则等待。
  • release()：释放一个许可，增加可用许可数。
  • tryAcquire()：尝试获取一个许可，如果成功则返回 true，否则返回 false。
  • availablePermits()：返回当前可用的许可数。
Semaphore semaphore = new Semaphore(3);

try {
    semaphore.acquire(); // 获取许可
    // 执行需要控制并发的方法
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    semaphore.release(); // 释放许可
}

2.3 底层实现

Semaphore 的底层实现主要依赖于 AQS（AbstractQueuedSynchronizer）。AQS 是一个用于构建锁和同步器的框架，提供了FIFO队列来管理线程的等待状态。

2.3.1 AQS简介

AQS 通过内部的一个 state 变量来维护同步状态：

  • state > 0：表示有可用的许可。
  • state == 0：表示没有可用的许可。
2.3.2 Semaphore内部类

Semaphore 通过继承 AQS 并重写其方法来实现许可管理。其内部类主要有以下两个：

  • NonfairSync：非公平模式的同步器。
  • FairSync：公平模式的同步器。
2.3.3 acquire() 的实现

当线程调用 acquire() 方法时，Semaphore 会尝试获取许可，如果 state > 0 则直接减1，否则将当前线程加入等待队列。

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

protected int tryAcquireShared(int acquires) {
    for (;;) {
        int available = getState();
        int remaining = available - acquires;
        if (remaining < 0 || compareAndSetState(available, remaining))
            return remaining;
    }
}
2.3.4 release() 的实现

当线程调用 release() 方法时，Semaphore 会增加 state 的值，并唤醒等待队列中的一个线程。

好的，让我们继续深入探讨 Semaphore 的底层原理和实际应用场景。

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

protected boolean tryReleaseShared(int releases) {
    for (;;) {
        int current = getState();
        int next = current + releases;
        if (next < current) // overflow check
            throw new Error("Maximum permit count exceeded");
        if (compareAndSetState(current, next))
            return true;
    }
}

在这个实现中，tryReleaseShared 方法通过一个无限循环尝试增加 state，并使用 compareAndSetState 确保线程安全。

3. Semaphore的实际应用场景

Semaphore 在实际开发中有很多应用场景，特别是在需要限制资源访问数量的地方。以下是几个常见的应用场景：

3.1 限制数据库连接数

在高并发环境中，数据库连接是宝贵的资源，过多的连接可能导致数据库压力过大，影响性能。使用 Semaphore 可以限制同时访问数据库的连接数。

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

public class DatabaseConnectionLimiter {
    private static final int MAX_CONNECTIONS = 5;
    private static final Semaphore semaphore = new Semaphore(MAX_CONNECTIONS);

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    semaphore.acquire();
                    accessDatabase();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }

        executor.shutdown();
    }

    private static void accessDatabase() {
        System.out.println(Thread.currentThread().getName() + " accessing database...");
        try {
            Thread.sleep(2000); // 模拟数据库操作
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " done accessing database.");
    }
}

3.2 控制并发执行的任务数量

在一些场景中，我们需要限制并发执行的任务数量，以防止系统过载。例如，限制同时处理的文件数量。

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

public class FileProcessor {
    private static final int MAX_CONCURRENT_TASKS = 3;
    private static final Semaphore semaphore = new Semaphore(MAX_CONCURRENT_TASKS);

    public static void main(String[] args) {
        ExecutorService executor = Executors.newFixedThreadPool(10);

        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    semaphore.acquire();
                    processFile();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            });
        }

        executor.shutdown();
    }

    private static void processFile() {
        System.out.println(Thread.currentThread().getName() + " processing file...");
        try {
            Thread.sleep(3000); // 模拟文件处理
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " done processing file.");
    }
}

3.3 控制资源池的访问

Semaphore 也可以用于控制对资源池的访问，例如对象池、线程池等。通过限制同时访问资源池的线程数量，避免资源争用和性能下降。

import java.util.concurrent.Semaphore;

public class ResourcePool {
    private static final int MAX_RESOURCES = 5;
    private static final Semaphore semaphore = new Semaphore(MAX_RESOURCES);
    private static final Resource[] resources = new Resource[MAX_RESOURCES];

    static {
        for (int i = 0; i < MAX_RESOURCES; i++) {
            resources[i] = new Resource(i);
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                Resource resource = null;
                try {
                    semaphore.acquire();
                    resource = getResource();
                    useResource(resource);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    releaseResource(resource);
                    semaphore.release();
                }
            }).start();
        }
    }

    private static Resource getResource() {
        for (Resource resource : resources) {
            if (!resource.isInUse()) {
                resource.setInUse(true);
                return resource;
            }
        }
        return null;
    }
    
    private static void useResource(Resource resource) {
        System.out.println(Thread.currentThread().getName() + " using resource " + resource.getId());
        try {
            Thread.sleep(2000); // 模拟资源使用
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName() + " done using resource " + resource.getId());
    }

    private static void releaseResource(Resource resource) {
        if (resource != null) {
            resource.setInUse(false);
        }
    }

    static class Resource {
        private final int id;
        private boolean inUse;

        public Resource(int id) {
            this.id = id;
            this.inUse = false;
        }

        public int getId() {
            return id;
        }

        public boolean isInUse() {
            return inUse;
        }

        public void setInUse(boolean inUse) {
            this.inUse = inUse;
        }
    }
}

在这个示例中，我们创建了一个资源池，并使用 Semaphore 来限制同时访问资源池的线程数量。每个线程在获取资源后进行使用，使用完毕后释放资源。

4. Semaphore在项目中的实战应用

为了让大家更好地理解 Semaphore 的实际应用，我们来做一个更复杂的项目实战示例。假设我们有一个Web服务，需要处理大量的请求，每个请求都需要访问一个第三方API。为了防止超出第三方API的访问限制，我们需要控制并发请求的数量。

4.1 示例项目结构

我们将创建一个简单的Web服务，使用 Spring Boot 框架，并在其中使用 Semaphore 来控制并发请求的数量。

项目结构如下：

semaphore-demo
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── semaphoredemo
│   │   │               ├── SemaphoreDemoApplication.java
│   │   │               ├── controller
│   │   │               │   └── ApiController.java
│   │   │               └── service
│   │   │                   └── ApiService.java
│   │   └── resources
│   │       └── application.yml
│   └── test
│       └── java
│           └── com
│               └── example
│                   └── semaphoredemo
│                       └── SemaphoreDemoApplicationTests.java

4.2 创建Spring Boot项目

首先，创建一个Spring Boot项目，并添加以下依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

4.3 编写ApiService类

ApiService 类负责处理对第三方API的请求，并使用 Semaphore 来控制并发请求的数量。

package com.example.semaphoredemo.service;

import org.springframework.stereotype.Service;

import java.util.concurrent.Semaphore;

@Service
public class ApiService {
    private static final int MAX_CONCURRENT_REQUESTS = 5;
    private final Semaphore semaphore = new Semaphore(MAX_CONCURRENT_REQUESTS);

    public String callExternalApi() throws InterruptedException {
        semaphore.acquire();
        try {
            // 模拟调用第三方API
            Thread.sleep(2000); // 模拟API响应时间
            return "Response from external API";
        } finally {
            semaphore.release();
        }
    }
}

4.4 编写ApiController类

ApiController 类提供一个HTTP端点，通过调用 ApiService 来处理请求。

package com.example.semaphoredemo.controller;

import com.example.semaphoredemo.service.ApiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ApiController {

    @Autowired
    private ApiService apiService;

    @GetMapping("/api")
    public String callApi() {
        try {
            return apiService.callExternalApi();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return "Failed to call external API";
            }
         }
       }

4.5 编写主应用程序类

SemaphoreDemoApplication 是我们的主应用程序类，负责启动Spring Boot应用。

package com.example.semaphoredemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SemaphoreDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(SemaphoreDemoApplication.class, args);
    }
}

4.6 配置文件

在 src/main/resources/application.yml 中，我们可以配置一些Spring Boot的默认设置。

server:
  port: 8080

spring:
  application:
    name: semaphore-demo

4.7 测试

我们可以创建一个简单的测试类来确保我们的应用程序能够正确处理并发请求。

package com.example.semaphoredemo;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class SemaphoreDemoApplicationTests {

    @Test
    void contextLoads() {
    }

}

4.8 运行和测试

运行我们的Spring Boot应用程序，然后使用工具（如 curl 或 Postman）发送多个并发请求到 http://localhost:8080/api。我们可以观察到，即使我们发送了超过5个并发请求，Semaphore 也会限制同时处理的请求数量为5个，剩余的请求会被阻塞直到有可用的许可。

# 使用curl进行并发请求测试
for i in {1..10}; do
  curl -X GET "http://localhost:8080/api" &
done
wait

5. 进一步优化和扩展

5.1 超时机制

我们可以为 Semaphore 添加超时机制，以防止线程无限期等待。

public String callExternalApi() throws InterruptedException {
    if (semaphore.tryAcquire(5, TimeUnit.SECONDS)) {
        try {
            // 模拟调用第三方API
            Thread.sleep(2000); // 模拟API响应时间
            return "Response from external API";
        } finally {
            semaphore.release();
        }
    } else {
        return "Failed to acquire semaphore - timeout";
    }
}

5.2 动态调整并发限制

我们可以通过配置文件或管理端点动态调整 Semaphore 的许可数量。

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "semaphore")
public class SemaphoreConfig {
    private int maxConcurrentRequests = 5;

    public int getMaxConcurrentRequests() {
        return maxConcurrentRequests;
    }

    public void setMaxConcurrentRequests(int maxConcurrentRequests) {
        this.maxConcurrentRequests = maxConcurrentRequests;
    }
}

在 ApiService 中使用 SemaphoreConfig：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.Semaphore;

@Service
public class ApiService {

    private final Semaphore semaphore;

    @Autowired
    public ApiService(SemaphoreConfig semaphoreConfig) {
        this.semaphore = new Semaphore(semaphoreConfig.getMaxConcurrentRequests());
    }

    public String callExternalApi() throws InterruptedException {
        semaphore.acquire();
        try {
            // 模拟调用第三方API
            Thread.sleep(2000);
            return "Response from external API";
        } finally {
            semaphore.release();
        }
    }
}

在 application.yml 中添加配置：

semaphore:
  max-concurrent-requests: 5

5.3 添加监控和报警

我们可以集成监控工具（如Prometheus和Grafana）来监控 Semaphore 的使用情况，并在并发请求过多时发送报警。

import io.micrometer.core.annotation.Timed;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.MeterBinder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ApiService implements MeterBinder {

    private final Semaphore semaphore;

    @Autowired
    public ApiService(SemaphoreConfig semaphoreConfig) {
        this.semaphore = new Semaphore(semaphoreConfig.getMaxConcurrentRequests());
    }

    @Timed("api.call")
    public String callExternalApi() throws InterruptedException {
        semaphore.acquire();
        try {
            // 模拟调用第三方API
            Thread.sleep(2000);
            return "Response from external API";
        } finally {
            semaphore.release();
        }
    }

5.3 添加监控和报警（续）

我们可以通过使用 Micrometer 和 Prometheus 来监控 Semaphore 的使用情况，并在并发请求过多时发送报警。首先，我们需要添加依赖项：

在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-core</artifactId>
</dependency>
<dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-prometheus</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
配置 ApiService 进行监控

我们可以通过 MeterRegistry 记录 Semaphore 的使用情况。以下是增强后的 ApiService：

import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.binder.MeterBinder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

@Service
public class ApiService implements MeterBinder {

    private final Semaphore semaphore;

    @Autowired
    public ApiService(SemaphoreConfig semaphoreConfig) {
        this.semaphore = new Semaphore(semaphoreConfig.getMaxConcurrentRequests());
    }

    public String callExternalApi() throws InterruptedException {
        if (semaphore.tryAcquire(5, TimeUnit.SECONDS)) {
            try {
                // 模拟调用第三方API
                Thread.sleep(2000);
                return "Response from external API";
            } finally {
                semaphore.release();
            }
        } else {
            return "Failed to acquire semaphore - timeout";
        }
    }

    @Override
    public void bindTo(MeterRegistry registry) {
        registry.gauge("semaphore.available.permits", semaphore, Semaphore::availablePermits);
        registry.gauge("semaphore.queue.length", semaphore, Semaphore::getQueueLength);
    }
}
配置 Prometheus 和 Grafana

在 src/main/resources/application.yml 中添加以下配置：

management:
  endpoints:
    web:
      exposure:
        include: "*"
  metrics:
    export:
      prometheus:
        enabled: true
  endpoint:
    prometheus:
      enabled: true
使用 Prometheus 和 Grafana 进行监控

  1. 启动 Prometheus：

    • 安装并配置 Prometheus，确保其能够从Spring Boot应用的 /actuator/prometheus 端点抓取数据。
    scrape_configs:
  - job_name: 'spring-boot'
    static_configs:
      - targets: ['localhost:8080']

  2. 启动 Grafana：

    • 安装并配置 Grafana，添加 Prometheus 作为数据源。
    • 创建仪表板，使用 semaphore.available.permits 和 semaphore.queue.length 指标进行监控。

5.4 添加熔断和限流

为了更好地保护系统，我们可以集成熔断器和限流机制，如 Resilience4j。

添加 Resilience4j 依赖

在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot2</artifactId>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-circuitbreaker</artifactId>
</dependency>
<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-ratelimiter</artifactId>
</dependency>
配置 Resilience4j

在 src/main/resources/application.yml 中添加以下配置：

resilience4j:
  circuitbreaker:
    instances:
      apiService:
        registerHealthIndicator: true
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10000
  ratelimiter:
    instances:
      apiService:
        limitForPeriod: 10
        limitRefreshPeriod: 1s
KK_crazy
关注
信号量Semaphore详解
m0_71777195的博客
11-30 5083
大家应该都用过关键字加锁，用来保证某个时刻只允许一个线程运行。那么如果控制某个时刻允许指定数量的线程执行，有什么好的办法呢?答案就是JUC提供的信号量Semaphore。Semaphore（信号量）可以用来限制能同时访问共享资源的线程上限，它内部维护了一个许可的变量，也就是线程许可的数量Semaphore的许可数量如果小于0个，就会阻塞获取，直到有线程释放许可Semaphore是一个非重入锁构造方法permits表示许可线程的数量fair表示公平性，如果设为true。
Java多线程——信号量Semaphore是啥
Arya的博客，专注后端领域
03-05 1147
Java多线程——信号量Semaphore是啥。
【多线程篇26】：信号量semaphore与控制方法并发操作详解
最新发布
lyh2004_08的博客
07-24 824
本文全面解析了Java并发编程中的Semaphore（信号量）机制。作为计数信号量，Semaphore通过permits（许可）控制资源并发访问线程数量，其工作原理类似于停车场管理模型。文章详细介绍了Semaphore的核心方法（acquire/release）和两种公平策略（公平/非公平），并通过线程池模拟10个线程访问限制3个并发的实战案例演示其应用。底层实现上，Semaphore基于AQS（AbstractQueuedSynchronizer）构建，采用共享模式并通过CAS操作维护state变量。特别
详解Java信号量-Semaphore
BASK2311的博客
01-13 1091
基本概念：Semaphore是一种基于计数的同步工具，用于控制同时访问特定资源的线程数量。原理理解：Semaphore的实现依赖于AQS（AbstractQueuedSynchronizer），提供了一种机制来管理和控制线程的访问。实际应用：从资源池管理到限流控制，Semaphore在多种场景中都非常有用。高级特性：包括公平性和非公平性的选择，以及对线程中断的响应。问题解决：面对资源耗尽和性能问题，咱们学习了如何妥善处理Semaphore带来的挑战。与其他工具结合。
Java之Semaphore
热门推荐
shihuacai的专栏
04-26 3万+
一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。拿到信号量的线程可以进入代码，否则就等待。通过acquire()和release()获取和释放访问许可
Java中的Semaphore
moonNife的专栏
06-24 2265
Java中的Semaphore是控制并发资源访问的关键工具，采用许可证机制实现流量限制。它基于AQS共享锁模式实现，支持公平与非公平两种获取方式，并提供acquire/release等核心操作。典型应用场景包括连接池管理、API限流和硬件资源共享。使用时需注意许可证泄漏问题，建议在finally块中释放许可。Semaphore特别适合读多写少的高并发场景，能有效提升系统稳定性，但需合理设置许可证数量并避免嵌套死锁。
JAVA并发编程【Semaphore】源码解析
qq_43600166的博客
06-24 852
Semaphore翻译过来的意思是信号、信号量。该类的主要作用是用于限制线程访问共享资源的数量。通俗一点来说，就是起到限流的作用。比如我们最常见的接口限流：当我们对外暴露一个接口时，应该对该接口的最大并行数进行控制。而Semaphore正好可以控制线程访问共享资源的数量，因此在单机部署的情况下，可以使用Semaphore来处理接口限流。synchronized关键字想必大家并不会感到陌生，synchronized可以控制共享资源同时只能被一个线程访问，而Semaphore更像是synchronized的升级
Java并发编程Semaphore计数信号量详解
08-29
Java并发编程Semaphore计数信号量详解 Java并发编程中，Semaphore（信号量）是一种高效的同步机制，允许一定数量的线程访问某个资源。在本文中，我们将详细介绍Java并发编程Semaphore计数信号量的工作原理和应用。 ...
Java并发编程Semaphore深度解析
"本文详细解析了Java并发编程中的Semaphore计数信号量，包括其概念、功能以及如何使用。" Semaphore在Java并发编程中扮演着重要的角色，它是一个计数信号量，用于控制对有限资源的访问。这个资源可以是物理的，如...
java并发之Semaphore信号量.md
07-24
Semaphore是计数信号量。Semaphore管理一系列许可证。每个acquire方法阻塞，直到有一个许可证可以获得然后拿走一个许可证；每个release方法增加一个许可证，这可能会释放一个阻塞的acquire方法。然而，其实并没有...
java线程并发semaphore类示例
09-04
总结来说，Semaphore在Java并发编程中扮演着重要的角色，它提供了对资源访问的有效控制，避免了过多的并发导致的问题，实现了线程之间的协作和同步。在实际开发中，根据需求合理地使用Semaphore可以帮助优化系统的...
Java并发工具之Semaphore
weixin_41951205的博客
02-28 1万+
一、简介 摘自《Java并发编程的艺术》一书 Semaphore（信号量）是用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理的使用公共资源。 Semaphore一般用于流量的控制，特别是公共资源有限的应用场景。例如数据库的连接，假设数据库的连接数上线为10个，多个线程并发操作数据库可以使用Semaphore来控制并发操作数据库的线程个数最多为10个。 二、类总览 通过上面的类图可以看到，Semaphore与ReentrantLock的内部类的结构相同，类内部总共存在Sync、Nonf
Java中的 Semaphores
盲目的拾荒者的博客
09-24 653
1.介绍 探索 Java 中信号量和互斥体的基础知识。 2. Semaphore 从 java.util.concurrent.Semaphore 开始，可以使用信号量来限制访问特定资源的并发线程数。 在下面的例子中，将实现一个简单的登录队列来限制系统中的用户数量： public class LoginQueueUsingSemaphore { private Semaphore semaphore; public LoginQueueUsingSemaphore(int slotLimi
Java并发之Semaphore详解
weixin_34365635的博客
08-09 1399
一、入题 Semaphore是一种基于计数的信号量。它可以设定一个阈值，基于此，多个线程竞争获取许可信号，做完自己的申请后归还，超过阈值后，线程申请许可信号将会被阻塞。Semaphore可以用来构建一些对象池，资源池之类的，比如数据库连接池，我们也可以创建计数为1的Semaphore，将其作为一种类似互斥锁的机制，这也叫二...
java中Semaphore
zhouguizhi
10-30 898
java 使用Semaphore实现信号灯
什么是Java 中的 Semaphore？
qq_33326733的博客
06-02 939
在多线程编程中，如何有效地控制多个线程对共享资源的访问是一个重要的问题。Semaphore（信号量）是 Java 中一个重要的同步工具，用于控制同时访问特定资源的线程数量。本文将深入探讨Semaphore的产生背景、基本使用、工作原理及其广泛的应用场景。
深入解析Java中的Semaphore
pleaseprintf的博客
06-19 6041
Semaphore是Java中的一种同步工具，用于控制对共享资源的访问。它可以用来限制同时访问某个资源的线程数量，提供了一种有效的并发控制机制。在本文中，我们将深入解析Java中的Semaphore，包括其概念、用法和常见应用场景。Semaphore是Java中一种重要的并发控制工具，通过管理许可证数量，可以限制对共享资源的并发访问。它在多线程编程中有着广泛的应用，能够有效地控制线程的并发性，保证共享资源的安全性和可靠性。在实际开发中，合理使用Semaphore可以提高程序的性能和稳定性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值