Java Executors工具线程池的使用

系统管理员 2022-06-08 11:12 190阅读 0赞

转载：http://cuisuqiang.iteye.com/blog/2019372

在面向对象编程中，创建和销毁对象是很费时间的，因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数，特别是一些很耗资源的对象创建和销毁，这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池（容器）中，需要的时候从池中获取线程不用自行创建，使用完毕不需要销毁线程而是放回池中，从而减少创建和销毁线程对象的开销。

Java 5+中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，因此在工具类Executors面提供了一些静态工厂方法，生成一些常用的线程池，如下所示：

**newCachedThreadPool**：创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程（线程池为无限大）。  
**newFixedThreadPool**：创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待（定长线程池的大小最好根据系统资源进行设置。如Runtime .getRuntime() .availableProcessors()）。  
**newScheduledThreadPool**：创建一个定长线程池，支持定时及周期性任务执行。  
**newSingleThreadExecutor**：创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

**(1) newCachedThreadPool**  
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。示例代码如下：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.ExecutorService; 
3.  **import** java.util.concurrent.Executors; 
4.  **public** **class** ThreadPoolExecutorTest \{ 
5.  **public** **static** **void** main(String\[\] args) \{ 
6.   ExecutorService cachedThreadPool = Executors.newCachedThreadPool(); 
7.  **for** (**int** i = 0; i < 10; i++) \{ 
8.  **final** **int** index = i; 
9.  **try** \{ 
10.  Thread.sleep(index \* 1000); 
11.  \} **catch** (InterruptedException e) \{ 
12.  e.printStackTrace(); 
13.  \} 
14.  cachedThreadPool.execute(**new** Runnable() \{ 
15. **public** **void** run() \{ 
16.  System.out.println(index); 
17.  \} 
18.  \}); 
19.  \} 
20.  \} 
21. \}

线程池为无限大，当执行第二个任务时第一个任务已经完成，会复用执行第一个任务的线程，而不用每次新建线程。  
  
(2) newFixedThreadPool  
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。示例代码如下：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.ExecutorService; 
3.  **import** java.util.concurrent.Executors; 
4.  **public** **class** ThreadPoolExecutorTest \{ 
5.  **public** **static** **void** main(String\[\] args) \{ 
6.   ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3); 
7.  **for** (**int** i = 0; i < 10; i++) \{ 
8.  **final** **int** index = i; 
9.   fixedThreadPool.execute(**new** Runnable() \{ 
10. **public** **void** run() \{ 
11. **try** \{ 
12.  System.out.println(index); 
13.  Thread.sleep(2000); 
14.  \} **catch** (InterruptedException e) \{ 
15.  e.printStackTrace(); 
16.  \} 
17.  \} 
18.  \}); 
19.  \} 
20.  \} 
21. \}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字。  
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()

(3) newScheduledThreadPool  
创建一个定长线程池，支持定时及周期性任务执行。延迟执行示例代码如下：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.Executors; 
3.  **import** java.util.concurrent.ScheduledExecutorService; 
4.  **import** java.util.concurrent.TimeUnit; 
5.  **public** **class** ThreadPoolExecutorTest \{ 
6.  **public** **static** **void** main(String\[\] args) \{ 
7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); 
8.   scheduledThreadPool.schedule(**new** Runnable() \{ 
9.  **public** **void** run() \{ 
10.  System.out.println("delay 3 seconds"); 
11.  \} 
12.  \}, 3, TimeUnit.SECONDS); 
13.  \} 
14. \}

表示延迟3秒执行。

定期执行示例代码如下：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.Executors; 
3.  **import** java.util.concurrent.ScheduledExecutorService; 
4.  **import** java.util.concurrent.TimeUnit; 
5.  **public** **class** ThreadPoolExecutorTest \{ 
6.  **public** **static** **void** main(String\[\] args) \{ 
7.   ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5); 
8.   scheduledThreadPool.scheduleAtFixedRate(**new** Runnable() \{ 
9.  **public** **void** run() \{ 
10.  System.out.println("delay 1 seconds, and excute every 3 seconds"); 
11.  \} 
12.  \}, 1, 3, TimeUnit.SECONDS); 
13.  \} 
14. \}

表示延迟1秒后每3秒执行一次。

(4) newSingleThreadExecutor  
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.ExecutorService; 
3.  **import** java.util.concurrent.Executors; 
4.  **public** **class** ThreadPoolExecutorTest \{ 
5.  **public** **static** **void** main(String\[\] args) \{ 
6.   ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor(); 
7.  **for** (**int** i = 0; i < 10; i++) \{ 
8.  **final** **int** index = i; 
9.   singleThreadExecutor.execute(**new** Runnable() \{ 
10. **public** **void** run() \{ 
11. **try** \{ 
12.  System.out.println(index); 
13.  Thread.sleep(2000); 
14.  \} **catch** (InterruptedException e) \{ 
15.  e.printStackTrace(); 
16.  \} 
17.  \} 
18.  \}); 
19.  \} 
20.  \} 
21. \}

结果依次输出，相当于顺序执行各个任务。

你可以使用JDK自带的监控工具来监控我们创建的线程数量，运行一个不终止的线程，创建指定量的线程，来观察：  
工具目录：**C:\\Program Files\\Java\\jdk1.6.0\_06\\bin\\jconsole.exe**  
运行程序做稍微修改：

Java代码 ![收藏代码][icon_star.png]

1.  **package** test; 
2.  **import** java.util.concurrent.ExecutorService; 
3.  **import** java.util.concurrent.Executors; 
4.  **public** **class** ThreadPoolExecutorTest \{ 
5.  **public** **static** **void** main(String\[\] args) \{ 
6.   ExecutorService singleThreadExecutor = Executors.newCachedThreadPool(); 
7.  **for** (**int** i = 0; i < 100; i++) \{ 
8.  **final** **int** index = i; 
9.   singleThreadExecutor.execute(**new** Runnable() \{ 
10. **public** **void** run() \{ 
11. **try** \{ 
12. **while**(**true**) \{ 
13.  System.out.println(index); 
14.  Thread.sleep(10 \* 1000); 
15.  \} 
16.  \} **catch** (InterruptedException e) \{ 
17.  e.printStackTrace(); 
18.  \} 
19.  \} 
20.  \}); 
21. **try** \{ 
22.  Thread.sleep(500); 
23.  \} **catch** (InterruptedException e) \{ 
24.  e.printStackTrace(); 
25.  \} 
26.  \} 
27.  \} 
28. \}

[icon_star.png]: /images/20220608/3e26bf4fad9d454f9d8fee7c75026fb6.png