线程池newFixedThreadPool的使用

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
/**
* 线程池newFixedThreadPool的使用。
*/
public class ExecutorTest{
public static void main(String args[]) {
    Random random = new Random();
    //产生一个 ExecutorService 对象，这个对象带有一个大小为 poolSize 的线程池，若任务数量大于 poolSize ，任务会被放在一个 queue 里顺序执行。 
    ExecutorService executor = Executors.newFixedThreadPool(3);
    // 判断可是线程池可以结束
    int waitTime = 500;
    for (int i = 0; i < 10; i++) {
      String name = "线程 " + i;
      int time = random.nextInt(1000);
      waitTime += time;
      Runnable runner = new ExecutorThread(name, time);
      System.out.println("增加: " + name + " / " + time);
      executor.execute(runner);
    }
    try {
      Thread.sleep(waitTime);
      executor.shutdown();
      executor.awaitTermination(waitTime, TimeUnit.MILLISECONDS);
    } catch (InterruptedException ignored) {
    }
}
}
class ExecutorThread implements Runnable {
private final String name;
private final int delay;
public ExecutorThread(String name, int delay) {
    this.name = name;
    this.delay = delay;
}
public void run() {
    System.out.println("启动: " + name);
    try {
      Thread.sleep(delay);
    } catch (InterruptedException ignored) {
    }
    System.out.println("完成: " + name);
}
}

/**运行结果
增加: 线程 0 / 900
增加: 线程 1 / 679
增加: 线程 2 / 840
增加: 线程 3 / 801
增加: 线程 4 / 153
增加: 线程 5 / 624
增加: 线程 6 / 430
增加: 线程 7 / 431
增加: 线程 8 / 522
增加: 线程 9 / 452
启动: 线程 0
启动: 线程 2
启动: 线程 1
完成: 线程 1
启动: 线程 3
完成: 线程 2
启动: 线程 4
完成: 线程 0
启动: 线程 5
完成: 线程 4
启动: 线程 6
完成: 线程 6
启动: 线程 7
完成: 线程 3
启动: 线程 8
完成: 线程 5
启动: 线程 9
完成: 线程 7
完成: 线程 9
完成: 线程 8 
*/

注：

Executors 类

   虽然以上提到的接口有其实现的具体类，但为了方便 Java 5.0 建议使用 Executors 的工具类来得到 Executor 接口的具体对象，需要注意的是 Executors 是一个类，不是 Executor 的复数形式。 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 里等待执行

转载地址：http://hi.baidu.com/niningzoulai/item/292ca20d88dc7dc891571812