3.6.2 创建线程池

package multithread2;
import java.util.LinkedList;
public class ThreadPool extends ThreadGroup {
private boolean isClosed=false;     //线程池是否关闭
private LinkedList<Runnable> workQueue;   //表示工作队列
private static int threadPoolID;     //表示线程池ID
private int threadID;      //表示工作线程ID

  public ThreadPool(int poolSize) {    //poolSize指定线程池中的工作线程数目
super("ThreadPool-" + (threadPoolID++));
setDaemon(true);
workQueue = new LinkedList<Runnable>();   //创建工作队列
for (int i=0; i<poolSize; i++)
new WorkThread().start();     //创建并启动工作线程
}

/** 向工作队列中加入一个新任务，由工作线程去执行该任务 */
public synchronized void execute(Runnable task) {
if (isClosed) {      //线程池被关则抛出IllegalStateException异常
throw new IllegalStateException();
}
if (task != null) {
workQueue.add(task);
notify();       //唤醒正在getTask()方法中等待任务的工作线程
}
}

  /** 从工作队列中取出一个任务，工作线程会调用此方法 */
protected synchronized Runnable getTask()throws InterruptedException{
while (workQueue.size() == 0) {
if (isClosed) return null;
wait();       //如果工作队列中没有任务，就等待任务
}
return workQueue.removeFirst();
}

  /** 关闭线程池 */
public synchronized void close() {
if (!isClosed) {
isClosed = true;
workQueue.clear();     //清空工作队列
interrupt();       //中断所有的工作线程，该方法继承自ThreadGroup类
}
}

  /** 等待工作线程把所有任务执行完 */
public void join() {
synchronized (this) {
isClosed = true;
notifyAll();       //唤醒还在getTask()方法中等待任务的工作线程
}

    Thread[] threads = new Thread[activeCount()];
//enumerate()方法继承自ThreadGroup类，获得线程组中当前所有活着的工作线程
int count = enumerate(threads);  
for (int i=0; i<count; i++) {    //等待所有工作线程运行结束
try {
threads[i].join();     //等待工作线程运行结束
}catch(InterruptedException ex) { }
}
}

  /**  内部类：工作线程  */
private class WorkThread extends Thread {
public WorkThread() {
//加入到当前ThreadPool线程组中
super(ThreadPool.this,"WorkThread-" + (threadID++));
}

    public void run() {
while (!isInterrupted()) {  //isInterrupted()方法继承自Thread类，判断线程是否被中断
Runnable task = null;
try {       //取出任务
task = getTask();
}catch (InterruptedException ex){}

        // 如果getTask()返回null或者线程执行getTask()时被中断，则结束此线程
if (task == null) return;

try { //运行任务，异常在catch代码块中捕获
task.run();
} catch (Throwable t) {
t.printStackTrace();
}
}      //#while
}       //#run()
}       //#WorkThread类
}     

  /** 关闭线程池 */
public synchronized void close() {
if (!isClosed) {
isClosed = true;
workQueue.clear();   //清空工作队列
interrupt();     //中断所有的工作线程，该方法继承自ThreadGroup类
}
}    

package multithread2;
public class ThreadPoolTester {
public static void main(String[] args) {
if (args.length != 2) {
System.out.println(
"用法: java ThreadPoolTest numTasks poolSize");
System.out.println(
"  numTasks - integer: 任务的数目");
System.out.println(
"  numThreads - integer: 线程池中的线程数目");
return;
}
int numTasks = Integer.parseInt(args[0]);
int poolSize = Integer.parseInt(args[1]);

   ThreadPool threadPool = new ThreadPool(poolSize);    //创建线程池

    // 运行任务
for (int i=0; i<numTasks; i++)
threadPool.execute(createTask(i));

threadPool.join();        //等待工作线程完成所有的任务
// threadPool.close();       //关闭线程池
}//#main()

/**  定义了一个简单的任务(打印ID)   */
private static Runnable createTask(final int taskID) {
return new Runnable() {
public void run() {
System.out.println("Task " + taskID + ": start");
try {
Thread.sleep(500);       //增加执行一个任务的时间
} catch (InterruptedException ex) { }
System.out.println("Task " + taskID + ": end");
}
};
}
}  

Task 0: start
Task 1: start
Task 2: start
Task 0: end
Task 3: start
Task 1: end
Task 4: start
Task 2: end
Task 3: end
Task 4: end

package multithread2;
import java.io.*;
import java.net.*;
public class EchoServer {
private int port=8000;
private ServerSocket serverSocket;
private ThreadPool threadPool;      //线程池
private final int POOL_SIZE=4;      //单个CPU时线程池中工作线程的数目

  public EchoServer() throws IOException {
serverSocket = new ServerSocket(port);
//创建线程池
//Runtime的availableProcessors()方法返回当前系统的CPU的数目
//系统的CPU越多，线程池中工作线程的数目也越多 
threadPool= new ThreadPool( 
Runtime.getRuntime().availableProcessors() * POOL_SIZE);

    System.out.println("服务器启动");
}

  public void service() {
while (true) {
Socket socket=null;
try {
socket = serverSocket.accept();
threadPool.execute(new Handler(socket));   //把与客户通信的任务交给线程池
}catch (IOException e) {
e.printStackTrace();
}
}
}

  public static void main(String args[])throws IOException {
new EchoServer().service();
}
}

/** 负责与单个客户通信的任务，代码与3.6.1节的例程3-5的Handler类相同 */
class Handler implements Runnable{…}