原文： https://javatutorial.net/java-thread-pool-example

活动线程消耗系统资源，这可能导致 JVM 创建太多线程，这意味着系统将很快用尽内存。

Java 线程池示例 - 图1

这就是 Java 中的线程池有助于解决的问题。

线程池如何工作？

线程池将先前创建的线程重用于当前任务。 这就解决了需要太多线程的问题，因此内存不足不是一个选择。 您甚至可以将线程池视为回收系统。 它不仅消除了用尽内存的选项，而且还使应用程序非常快速地响应，因为当请求到达时已经存在一个线程。

Java 线程池示例 - 图2

上图的工作流不仅可以控制应用程序正在创建的线程数，还可以控制计划任务的执行并将传入的任务保持在队列中。

Executor，Runnable和ExecutorService

Java 提供了Executor框架，这意味着您只需要实现Runnable对象并将其发送给执行器即可执行。

要使用线程池，首先我们需要创建一个ExecutorService对象并将任务传递给它。ThreadPoolExecutor类设置核心和最大池大小。 然后，可运行对象将顺序执行。

不同的Executor线程池方法

  1. newFixedThreadPool(int size) - creates a fixed size thread pool
  3. newCachedThreadPool() - creates a thread pool that creates new threads if needed but will also use previous threads if they are available
  5. newSingleThreadExecutor() - creates a single thread

ExecutorService接口包含许多方法，这些方法用于控制任务的进度并管理服务的终止。 您可以使用Future实例控制任务的执行。 有关如何使用Future的示例：

  1. ExecutorService execService = Executors.newFixedThreadPool(6);
  2. Future<String> future = execService.submit(() -> "Example");
  3. String result = future.get();

ThreadPoolExecutor使您可以实现具有许多参数的可扩展线程池，这些参数包括corePoolSize，maximumPoolSize，keepAliveTime，unit，workQueue，handler，threadFactor。 但是，corePoolSize，maximumPoolSize和keepAliveTime是主要变量，因为它们在每个构造函数中都使用。

corePoolSize是要保留在池中的线程数，即使它们处于空闲状态，除非设置了allowCoreThreadTimeOut。

maximumPoolSize是池中允许的最大线程数。

keepAliveTime是当线程数大于内核数时，这是多余的空闲线程将在终止之前等待新任务的最长时间。

有关其他参数的更多信息，请访问原始 Oracle 文档。

线程池实现示例

工作流程步骤：

  1. 创建要执行的任务
  2. 使用执行程序创建执行程序池
  3. 将任务传递给执行程序池
  4. 关闭执行程序池

Task.java

  1. import java.text.SimpleDateFormat;  
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  6. // (Step 1) 
  7. public class Task implements Runnable    { 
  8.     private String name; 
  10.     public Task(String name) { 
  11.         this.name = name; 
  12.     } 
  14.     public void run() { 
  15.         try {
  16.             for (int i = 0; i < 5; i++) { 
  17.                 if (i == 1) { 
  18.                     Date date = new Date(); 
  19.                     SimpleDateFormat ft = new SimpleDateFormat("hh:mm:ss"); 
  20.                     System.out.println("Time initialization for task " + this.name + " is " + ft.format(date));    
  21.                 } 
  22.                 else { 
  23.                     Date date = new Date(); 
  24.                     SimpleDateFormat ft = new SimpleDateFormat("hh:mm:ss"); 
  25.                     System.out.println("Execution time for task " + this.name + " is " + ft.format(date));    
  26.                 } 
  27.                 Thread.sleep(1000); 
  28.             } 
  29.         } 
  30.         catch(InterruptedException error) { 
  31.             error.printStackTrace(); 
  32.         } 
  33.         System.out.println(this.name + " completed"); 
  34.     } 
  35. }

Main.java

  1. import java.text.SimpleDateFormat;  
  2. import java.util.Date; 
  3. import java.util.concurrent.ExecutorService; 
  4. import java.util.concurrent.Executors; 
  6. public class Main { 
  7.     public static void main(String[] args) { 
  8.         Runnable task1 = new Task("task 1"); 
  9.         Runnable task2 = new Task("task 2"); 
  10.         Runnable task3 = new Task("task 3"); 
  11.         Runnable task4 = new Task("task 4"); 
  12.         Runnable task5 = new Task("task 5");       
  14.         // (Step 2) 
  15.         ExecutorService pool = Executors.newFixedThreadPool(3);   
  17.         // (Step 3) 
  18.         pool.execute(task1); 
  19.         pool.execute(task2); 
  20.         pool.execute(task3); 
  21.         pool.execute(task4); 
  22.         pool.execute(task5);  
  24.         // (Step 4) 
  25.         pool.shutdown();     
  26.     } 
  27. }

输出：

  1. Time initialization for task task 2 is 10:18:40
  2. Time initialization for task task 1 is 10:18:40
  3. Time initialization for task task 3 is 10:18:40
  4. Execution time for task task 3 is 10:18:41
  5. Execution time for task task 1 is 10:18:41
  6. Execution time for task task 2 is 10:18:41
  7. Execution time for task task 2 is 10:18:42
  8. Execution time for task task 3 is 10:18:42
  9. Execution time for task task 1 is 10:18:42
  10. Execution time for task task 1 is 10:18:43
  11. Execution time for task task 3 is 10:18:43
  12. Execution time for task task 2 is 10:18:43
  13. Execution time for task task 3 is 10:18:44
  14. Execution time for task task 1 is 10:18:44
  15. Execution time for task task 2 is 10:18:44
  16. task 2 completed
  17. task 1 completed
  18. task 3 completed
  19. Time initialization for task task 4 is 10:18:45
  20. Time initialization for task task 5 is 10:18:45
  21. Execution time for task task 4 is 10:18:46
  22. Execution time for task task 5 is 10:18:46
  23. Execution time for task task 4 is 10:18:47
  24. Execution time for task task 5 is 10:18:47
  25. Execution time for task task 5 is 10:18:48
  26. Execution time for task task 4 is 10:18:48
  27. Execution time for task task 4 is 10:18:49
  28. Execution time for task task 5 is 10:18:49
  29. task 4 completed
  30. task 5 completed

上面的代码实现的细分：

Task.java表示任务类。 每个任务都有一个名称实例变量，并且每个任务都使用构造函数实例化。 此类有 1 个方法，称为run。 在run方法的主体内，有一个for循环，该循环根据存在的任务数进行迭代。 在我们的例子中，有 5 个任务，这意味着它将运行 5 次。 第一次迭代，显示当前任务初始化的时间。 其他迭代，打印执行时间。 打印完成后，有一个Thread.sleep()方法调用，该方法用于以 1 秒的延迟显示每个迭代消息。 注意，像这样调用的方法名称run非常重要，因为它是来自Task类正在实现的Runnable的抽象方法。

仅在池中的某个胎面变得空闲时才执行任务 4 和 5。 在此之前，额外的任务将放置在队列中。

执行完所有任务后，请关闭线程池。

线程池何时有用

组织服务器应用程序时。 如本文开头所述，在组织服务器应用程序时非常有用，因为使用线程池非常有效，就像有许多任务一样，它会自动将它们放入队列中。 不仅如此，它还可以防止内存不足，或者至少可以显着减慢这样做的速度。 使用ExecutorService使其更易于实现。