带有 ArrayBlockingQueue 的 ThreadPoolExecutor

当我在我的一个项目中使用 ThreadPoolExecutor 时，我开始从 Java Doc 中阅读更多有关 ThreadPoolExecutor 的内容。那么谁能解释一下这行代码实际上意味着什么？-我知道每个参数代表什么，但我想从这里的一些专家那里以更一般/外行的方式理解它。

ExecutorService service = new ThreadPoolExecutor(10, 10, 1000L,
TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10, true), new 
ThreadPoolExecutor.CallerRunsPolicy());

更新：-问题陈述是：-

每个线程使用 1 到 1000 之间的唯一 ID，并且程序必须运行 60 分钟或更长时间，因此在这 60 分钟内，所有 ID 可能都会完成，因此我需要再次重用这些 ID。这是我使用上面的执行器编写的以下程序。

class IdPool {
    private final LinkedList<Integer> availableExistingIds = new LinkedList<Integer>();

    public IdPool() {
        for (int i = 1; i <= 1000; i++) {
            availableExistingIds.add(i);
        }
    }

    public synchronized Integer getExistingId() {
        return availableExistingIds.removeFirst();
    }

    public synchronized void releaseExistingId(Integer id) {
        availableExistingIds.add(id);
    }
}


class ThreadNewTask implements Runnable {
    private IdPool idPool;

    public ThreadNewTask(IdPool idPool) {
        this.idPool = idPool;
    }

    public void run() {
        Integer id = idPool.getExistingId();
        someMethod(id);
        idPool.releaseExistingId(id);
    }

// This method needs to be synchronized or not?
    private synchronized void someMethod(Integer id) {
        System.out.println("Task: " +id);
// and do other calcuations whatever you need to do in your program
    }
}

public class TestingPool {
    public static void main(String[] args) throws InterruptedException {
        int size = 10;
        int durationOfRun = 60;
        IdPool idPool = new IdPool();   
        // create thread pool with given size
        ExecutorService service = new ThreadPoolExecutor(size, size, 500L, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(size), new ThreadPoolExecutor.CallerRunsPolicy()); 

        // queue some tasks
        long startTime = System.currentTimeMillis();
        long endTime = startTime + (durationOfRun * 60 * 1000L);

        // Running it for 60 minutes
        while(System.currentTimeMillis() <= endTime) {
            service.submit(new ThreadNewTask(idPool));
        }

        // wait for termination        
        service.shutdown();
        service.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); 
    }
}

我的问题是：- 就性能而言，这段代码是否正确？我还可以在这里做些什么来使其更准确？任何帮助将不胜感激。

[首先，我道歉，这是对之前答案的回应，但我想要格式化]。

但实际上，当将项目提交到队列已满的 ThreadPoolExecutor 时，您不会阻塞。原因是 ThreadPoolExecutor 调用 BlockingQueue.offer(T item) 方法，根据定义，该方法是非阻塞方法。它要么添加项目并返回 true，要么不添加（满时）并返回 false。然后ThreadPoolExecutor调用注册的RejectedExecutionHandler来处理这种情况。

来自javadoc：

在将来的某个时间执行给定的任务。任务可能会执行 在新线程或现有池线程中。如果任务无法完成 提交执行，要么因为这个执行者已经 关闭或因为其容量已达到，任务已处理 由当前的 RejectedExecutionHandler 执行。

默认情况下，使用 ThreadPoolExecutor.AbortPolicy()，它会从 ThreadPoolExecutor 的“submit”或“execute”方法抛出 RejectedExecutionException。

try {
   executorService.execute(new Runnable() { ... });
}
catch (RejectedExecutionException e) {
   // the queue is full, and you're using the AbortPolicy as the 
   // RejectedExecutionHandler
}

但是，您可以使用其他处理程序执行不同的操作，例如忽略错误（DiscardPolicy），或在调用“execute”或“submit”方法（CallerRunsPolicy）的线程中运行它。此示例允许调用“提交”或“执行”方法的线程在队列已满时运行请求的任务。 （这意味着在任何给定时间，您都可以在池本身的基础上运行 1 个额外的东西）：

ExecutorService service = new ThreadPoolExecutor(..., new ThreadPoolExecutor.CallerRunsPolicy());

如果您想阻塞并等待，您可以实现自己的 RejectedExecutionHandler ，它将阻塞直到队列上有可用的插槽（这是一个粗略的估计，我还没有编译或运行它，但您应该明白这个想法）：

public class BlockUntilAvailableSlot implements RejectedExecutionHandler {
  public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
     if (e.isTerminated() || e.isShutdown()) {
        return;
     }

     boolean submitted = false;
     while (! submitted) {
       if (Thread.currentThread().isInterrupted()) {
            // be a good citizen and do something nice if we were interrupted
            // anywhere other than during the sleep method.
       }

       try {
          e.execute(r);
          submitted = true;
       }
       catch (RejectedExceptionException e) {
         try {
           // Sleep for a little bit, and try again.
           Thread.sleep(100L);
         }
         catch (InterruptedException e) {
           ; // do you care if someone called Thread.interrupt?
           // if so, do something nice here, and maybe just silently return.
         }
       }
     }
  }
}