线程池的使用 ExecutorService newFixedThreadPool(int nThreads)

public static ExecutorService newFixedThreadPool(int nThreads)

创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。在任意点，在大多数 nThreads 线程会处于处理任务的活动状态。如果在所有线程处于活动状态时提交附加任务，则在有可用线程之前，附加任务将在队列中等待。如果在关闭前的执行期间由于失败而导致任何线程终止，那么一个新线程将代替它执行后续的任务（如果需要）。在某个线程被显式地关闭之前，池中的线程将一直存在。

  

看代码：

Java代码  

1. <span style="font-size: small;">package test;  
2.   
3. import java.util.Random;  
4. import java.util.concurrent.ExecutorService;  
5. import java.util.concurrent.Executors;  
6. import java.util.concurrent.TimeUnit;  
7.   
8. public class ExecutorTest {  
9.     public static void main(String args[]) {  
10.         Random random = new Random();  
11.         //产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。   
12.         ExecutorService executor = Executors.newFixedThreadPool(3);  
13.         // 判断可是线程池可以结束  
14.         int waitTime = 500;  
15.         for (int i = 0; i < 10; i++) {  
16.           String name = "线程 " + i;  
17.           int time = random.nextInt(1000);  
18.           waitTime += time;  
19.           Runnable runner = new ExecutorThread(name, time);  
20.           System.out.println("增加: " + name + " / " + time);  
21.           executor.execute(runner);  
22.         }  
23.         try {  
24.           Thread.sleep(waitTime);  
25.           executor.shutdown();  
26.           executor.awaitTermination(waitTime, TimeUnit.MILLISECONDS);  
27.         } catch (InterruptedException ignored) {  
28.         }  
29.     }  
30. }  
31.   
32.   
33. class ExecutorThread implements Runnable {  
34.     private final String name;  
35.     private final int delay;  
36.     public ExecutorThread(String name, int delay) {  
37.         this.name = name;  
38.         this.delay = delay;  
39.     }  
40.     public void run() {  
41.         System.out.println("启动: " + name);  
42.         try {  
43.           Thread.sleep(delay);  
44.         } catch (InterruptedException ignored) {  
45.         }  
46.         System.out.println("完成: " + name);  
47.     }  
48. }  
49. </span>  

 

将poolsize取不同值，得到的结果如下：

 

 

由上结果可以看出，线程池最多处理的线程数=poolsize。

 

 

Executors 类

   需要注意的是 Executors 是一个类，不是 Executor 的复数形式。该类是一个辅助类，此包中所定义的Executor、ExecutorService、ScheduledExecutorService、ThreadFactory和 Callable 类的工厂和实用方法。

此类支持以下各种方法：

• 创建并返回设置有常用配置字符串的 ExecutorService 的方法。

• 创建并返回设置有常用配置字符串的 ScheduledExecutorService 的方法。

• 创建并返回“包装的”ExecutorService 方法，它通过使特定于实现的方法不可访问来禁用重新配置。

• 创建并返回 ThreadFactory 的方法，它可将新创建的线程设置为已知的状态。

•创建并返回非闭包形式的 Callable 的方法，这样可将其用于需要 Callable 的执行方法中。

 Executors 提供了以下一些 static 的方法：

callable(Runnable task): 将 Runnable 的任务转化成 Callable 的任务

newSingleThreadExecutor: 产生一个 ExecutorService 对象，这个对象只有一个线程可用来执行任务，若任务多于一个，任务将按先后顺序执行。

newCachedThreadPool(): 产生一个 ExecutorService 对象，这个对象带有一个线程池，线程池的大小会根据需要调整，线程执行完任务后返回线程池，供执行下一次任务使用。

newFixedThreadPool(int poolSize) ： 产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。

newSingleThreadScheduledExecutor ：产生一个ScheduledExecutorService 对象，这个对象的线程池大小为 1 ，若任务多于一个，任务将按先后顺序执行。

newScheduledThreadPool(int poolSize): 产生一个ScheduledExecutorService 对象，这个对象的线程池大小为 poolSize ，若任务数量大于 poolSize ，任务会在一个 queue 里等待执行。

修改上面的代码，测试一下newCachedThreadPool，由结果可知：线程池大小按需最大可达10.而newSingleThreadExecutor只有一个线程。结果如下：