在Spring中限制调用方法的线程数(Boot)

在Spring Boot中限制调用方法的线程数，可以通过多种方式实现，具体取决于你的需求和应用的架构。以下是一些常见的方法：

1. 使用`@Async`注解和自定义线程池

Spring Boot提供了@Async注解，可以用来异步执行方法。你可以配置一个自定义的线程池来限制并发执行的线程数。

配置自定义线程池

首先，在配置类中定义一个自定义线程池：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5); // 核心线程数
        executor.setMaxPoolSize(10); // 最大线程数
        executor.setQueueCapacity(25); // 队列容量
        executor.setThreadNamePrefix("MyThread-");
        executor.initialize();
        return executor;
    }
}

使用`@Async`注解

然后，在需要异步执行的方法上添加@Async注解：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    @Async
    public void asyncMethod() {
        // 异步执行的代码
    }
}

2. 使用`Semaphore`

如果你不想使用异步执行，而是想在同步方法中限制并发访问，可以使用Semaphore。

示例代码

import java.util.concurrent.Semaphore;

public class MyService {

    private final Semaphore semaphore = new Semaphore(5); // 允许最多5个线程同时访问

    public void myMethod() {
        try {
            semaphore.acquire(); // 获取许可
            // 执行业务逻辑
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release(); // 释放许可
        }
    }
}

3. 使用`ReentrantLock`

另一种方法是使用ReentrantLock来控制并发访问。

示例代码

import java.util.concurrent.locks.ReentrantLock;

public class MyService {

    private final ReentrantLock lock = new ReynchronizedLock();

    public void myMethod() {
        lock.lock(); // 获取锁
        try {
            // 执行业务逻辑
        } finally {
            lock.unlock(); // 释放锁
        }
    }
}