如果你只是想限制可以访问你的服务的线程的最大数量，那么你可以使用Bounded信号量，并提供最大数量的许可。以下是示例代码（假设您的服务是单例服务）：

public class SampleService {
    private Semaphore semaphore = new Semaphore(n, true);

    public void someMothod() {
        try {
            semaphore.acquire();

            // execute the task

        } catch (InterruptedException e) {
        } finally {
            semaphore.release();
        }

    }
}

您必须确保只创建一个信号量示例。如果应用程序中可以有多个服务示例，那么将信号量设置为静态。

private static Semaphore semaphore = new Semaphore(n, true);

您可以使用ExecutorCompletionService来完成此操作。只需创建一个ExecutorService，固定如下所述的线程数

ExecutorService pool = Executors.newFixedThreadPool(5);

现在使用此ExecutorService创建ExecutorCompletionService。

ExecutorCompletionService completionService = new ExecutorCompletionService(pool);

然后在提交任务后，您可以迭代并获得未来以及来自未来的作业结果。当你使用从ExecutorService返回的Future时，这不会阻塞线程。

for(int i = 0; i < worker size ; i++) {
    Future future = completionService.take();

     Object content = future.get();

}

You can solve this by using both Semaphores and Future<T>. We have 2 types of Semaphores, i.e. Counting Semaphores and Binary Semaphores. If you want multiple threads to access your resource you, then use Counting semaphores.
Code example:

    public class RestrictApiCalls {
    private Sempaphore semaphore =  new Semaphore(3);
    private ExecutorService executor =  Executors.newFixedThreadPool(3);
    
     public void call(){
       try{
        semaphore.acquire();
        Future<String> future  =  executor.submit(()->{
         Thread.sleep(1000);
         return "Call successful";
        });
      try{
          String response  =  future.get();
        }catch(Exception e){
         //handle exception here
        }
     }catch(Exception e){
      // handle
    }
    finally{
     semaphore.release();
    }
    }
    }

    }