线程池实现tcp socket

前面的程序，当一个客户端请求到来时，服务器端就会临时性的创建一个新的线程来处理相应的客户端请求，当一个线程处理完了相应的客户端的任务之后，这个线程也就结束了自己的生命周期，不能再次被启用。这样开销是很大的。

线程池主要用来解决线程生命周期开销问题和资源不足问题。通过对多个任务重用线程。一个简单的线程池至少包括线程池管理器，线程池，工作线程，任务接口等部分，线程池管理器是创建，销毁并管理线程池，将工作线程放入线程池中，线程池的作用是维护一个线程池实例，工作线程是一个可以循环执行任务的线程，在没有任务时进行等待，任务接口是每个任务必须实现的接口。
客户端和前面的没什么不同
主要给出服务器端程序及线程池管理器和线程池类
服务器端：

package threadpool;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class PoolAdvanceServer { // 服务器端

	public static int clientCount = 0;
	static int port = 8888;
	[b]ThreadPool threadPool = PoolManager.getInstance().createThreadPool(100,
			ServerWorker.class); [/b]//从线程管理器中取得线程池

	public PoolAdvanceServer(){

	}

	public static void main(String[] args) {    //启动服务器端主程序

		PoolAdvanceServer server = new PoolAdvanceServer();
		try {
			server.listen(port);
		} catch (IOException e) {
			e.printStackTrace();
		}

	}

	private void listen(int port) throws IOException {

		ServerSocket server = new ServerSocket(port);
		System.out.println("The PoolAdvanceServer is listening......");
		while (true) { 
			clientCount++;
			Socket socket = server.accept();
			[b]threadPool.performWork(socket);[/b]
		}
	}
}

线程池管理类

package threadpool;

public class PoolManager { //线程池管理器，系统应保证只有一个实例，应用单例模式

	private static PoolManager instance = null; 
//	构造函数为私有的，保证外部类不可以实例化该类
	private PoolManager(){

	}
	public static PoolManager getInstance(){
		if(instance==null)instance = new PoolManager();
		return instance;
	}

	//创建线程池实例方法
	public ThreadPool createThreadPool(int max,Class worker){
		ThreadPool threadPool = null;
		try {
			threadPool = new ThreadPool(max,worker); //创建线程池实例
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		}
		return threadPool;
	}
}

线程池类

package threadpool;

import java.util.Stack;

public class ThreadPool {

	/*
	 * 任务处理类，该类被线程池调用
	 */
	class WorkerThread extends Thread {
		private Worker _worker;
		private Object _data;

		/*
		 * 任务处理类的构造函数
		 * 
		 * @param id 线程名称
		 * 
		 * @param worker 与该类关联的工作类
		 */

		public WorkerThread(String id, Worker worker) {

			super();
			_worker = worker;
			_data = null;
		}

		@Override
		synchronized public void run() {

			boolean stop = false;
			while (!stop) {
				if (_data == null) {
					try {
						wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
						continue;
					}
				}
				if (_data != null) {
					System.out.println(this.getName());
					_worker.run(_data);
				}
				_data = null;
				stop = !(_push(this));
			}
		}

		// 唤醒线程并作相应的处理工作
		synchronized public void wake(Object data) {
			_data = data;
			notify();

		}

	}

	private Stack _waiting; // 就绪线程栈
	private int _max; // 最大线程数
	private Class _workerClass; // 工作类

	public ThreadPool(int max, Class workerClass)
			throws InstantiationException, IllegalAccessException {

		_max = max;
		_waiting = new Stack();
		_workerClass = workerClass;

		Worker worker;
		WorkerThread w;

		for (int i = 0; i < _max; i++) {
			worker = (Worker) _workerClass.newInstance();
			w = new WorkerThread("Worker#" + i, worker);
			w.start();
			_waiting.push(w); // 进栈
		}

	}

	// 将处理完任务的线程归还给线程池
	public boolean _push(WorkerThread w) {
		boolean stayAround = false;
		synchronized (_waiting) {
			if (_waiting.size() < _max) {
				stayAround = true;
				_waiting.push(w);
			}
		}
		return stayAround;
	}

	public void performWork(Object data) { // 执行处理客户端请求的任务

		WorkerThread w = null;
		synchronized (_waiting) {
			if (_waiting.empty()) {
				try {
					w = new WorkerThread("additional worker",
							(Worker) _workerClass.newInstance());
					w.start();
				} catch (InstantiationException e) {
					e.printStackTrace();
				} catch (IllegalAccessException e) {
					e.printStackTrace();
				}
			} else {
				w = (WorkerThread) _waiting.pop();
			}
		}
		w.wake(data);

	}

}

工作接口

package threadpool;

public interface Worker {
	public void run(Object data);
}

工作类

package threadpool;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ServerWorker implements Worker {

	@Override
	public void run(Object data) {

		//处理客户端请求方法
		processRequest((Socket)data);
	}

	private void processRequest(Socket socket) {
		try {
			InputStream is = socket.getInputStream();
			OutputStream os = socket.getOutputStream();
			DataInputStream dis = new DataInputStream(is);
			DataOutputStream dos = new DataOutputStream(os);
			int receiveInt = dis.readInt(); // 读取客户端请求
			System.out.println("The message from client"+PoolAdvanceServer.clientCount+" is:" + receiveInt);
			dos.writeInt(receiveInt * 18); // 返回client端
			dos.flush(); // 强制清空缓冲区
			dos.close();
			dis.close();
			is.close();

			delay(10l);
//			线程处理完毕后，减少client端的数量
			PoolAdvanceServer.clientCount--;
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private void delay(long l) {

		try {
			Thread.sleep(l);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}