CompletableFuture并发处理，多线程，限流RateLimiter

限流的依赖

 		<dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>33.0.0-jre</version>
        </dependency>

@Configuration
@Slf4j
public class CustomExecutorConfig {

    /**
     * 自定义线程池
     *
     * @return
     */
    @Bean("customExecutor")
    public Executor getAsyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //此方法返回可用处理器的虚拟机的最大数量; 不小于1
        int core = Runtime.getRuntime().availableProcessors();
        //设置核心线程数
        executor.setCorePoolSize(100);
        //设置最大线程数
        executor.setMaxPoolSize(150);
        //除核心线程外的线程存活时间
        executor.setKeepAliveSeconds(30);
        //如果传入值大于0，底层队列使用的是LinkedBlockingQueue,否则默认使用SynchronousQueue
        executor.setQueueCapacity(200);
        //线程名称前缀
        executor.setThreadNamePrefix("my-executor-");
        //设置拒绝策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();

        return executor;
    }





}

	 @Resource(name = "customExecutor")
     private Executor executor;
     //如果需要控制速率，限流，每秒100个线程处理
     private final RateLimiter rateLimiter = RateLimiter.create(100.0);
     
    //dealMethod 为执行的方法
    //list为源数据
        CompletableFuture<String>[] completableFutures = list.stream().map(s->{
            return CompletableFuture.supplyAsync(() -> { 
              //如果并发处理时需要控制限流
               rateLimiter.acquire();
              return dealMethod(s.getText());}, executor);
        }).toArray(CompletableFuture[]::new);

        // 等待所有任务执行完
        CompletableFuture.allOf(completableFutures).join();

      for (CompletableFuture<String> completableFuture : completableFutures) {
             String str= completableFuture.get();
             //doString...................
        }

test代码

import com.google.common.util.concurrent.RateLimiter;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.Executor;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = Application.class)
public class RateLimitedTaskProcessor {
    private static final int THREAD_POOL_SIZE = 20; // 线程池大小
    private static final int RATE_LIMIT = 10; // 每秒最多处理的任务数

    @Resource(name = "customExecutor")
    private Executor executor;
    @Test
    public  void test() {
        // 创建一个线程池
//        ExecutorService executor = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

        // 创建一个RateLimiter，每秒最多处理10个任务
        RateLimiter rateLimiter = RateLimiter.create(RATE_LIMIT);

        // 模拟要处理的任务列表
        List<CompletableFuture<Void>> futures = new ArrayList<>();

        List<Integer> list=new ArrayList<>();
        for (int i = 1; i <= 50; i++) { // 假设有50个任务需要处理
            list.add(i);
        }



        CompletableFuture<Void>[] completableFutures = list.stream().map(s->{
            return CompletableFuture.runAsync(() ->{
                        rateLimiter.acquire();
                         processTask(s);
                    }
                    , executor);
        }).toArray(CompletableFuture[]::new);

        CompletableFuture.allOf(completableFutures).join();

        // 关闭线程池
//        executor.shutdown();
        System.out.println("All tasks completed.");
    }

    private static void processTask(int taskNumber) {
        //获取当前时间 格式为yyyyMMdd:HHmmss
        String time = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

        System.out.println("时间为:"+time+",Processing task " + taskNumber + " by " + Thread.currentThread().getName());
        // 模拟任务处理时间
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}