多线程就是并发技术，当线程数量超过一定数量时，系统响应就会变慢，所以就必须对线程数量进行控制，那么采用哪种控制方法呢？采用Stack类模仿堆栈，之所以说是模仿，就是因为Stack类毕竟不是真实的堆栈，push和pop操作也并非是真正的入栈和出栈操作！程序思路是创建一个线程池管理类ThreadPool类，这个类的作用是用于创建指定数量的工作线程并压入栈中，此外还负责唤醒线程进行工作（方法是performedWork(Object data)），还有一个将执行完任务的线程重新压入栈中的方法push()，在线程池类内部有一个嵌套的工作线程WorkerThread类，这个类就是具体负责执行任务的工作线程，但是任务的具体执行者是由接口Worker或继承了该接口的实际类完成的。这里有几个关键点，一个数据对象，在创建了线程但还没有传入data对象时线程是一直处于wait（）阻塞状态中。只有通过wake(Object data)方法进行唤醒并工作。
例程如下：
package thread.test;
import java.util.Stack;
public class StackThread {
static class WorkProcess implements Worker{
@Override
public void run(Object data) {
System.out.println(data);
}
}
public static void main(String[] args) throws Exception {
WorkProcess wp=new WorkProcess();
ThreadPool tp = new ThreadPool(wp.getClass(),10);
for(int i=0;i<11;i++) //输出的顺序是没有先后的,第十一个线程为额外线程
tp.performedWork("function#"+i);
}
}
class ThreadPool{
class WorkerThread extends Thread{
private Object data;
private Worker worker;
//工作线程需要两个参数，标识符和工作接口，还需要一个数据用于运行run(Object data)方法,在得到data对象之前，线程一直处于阻塞状态
public WorkerThread(String idoilt,Worker worker){
super(idoilt);
this.worker=worker;
data=null;
}
synchronized public void wake(Object data){
this.data=data;
this.notify();
}
@Override
synchronized public void run(){
boolean stop=false;
while(!stop){
if(data==null){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if(data!=null){ //下面这两句话可能不会同时输出，即线程会在输出第一句话之后切换到另外一个线程
System.out.println(this.getName());
worker.run(data);
}
data=null;
stop=push(this);
}
}
}
@SuppressWarnings("rawtypes")
private Stack _waiting; //被所有线程所共享的对象，所以必须同步，用于存放所有的工作线程
@SuppressWarnings("rawtypes")
private Class _workerClass;
int _max;
@SuppressWarnings({ "unchecked", "rawtypes" })
public ThreadPool(Class workerClass,int max)throws Exception{
_workerClass=workerClass;
_max=max;
_waiting =new Stack();
Worker wo;
WorkerThread wt;
for(int i=0;i<_max;i++){//创建一定数量的工作线程
wo=(Worker)_workerClass.newInstance(); //产生一个新的实例，均是继承于Worker接口。
wt=new WorkerThread("worker#"+i,wo);
wt.start();//请网友思考一下为什么这里要启动方法，而不在performedWork方法中启动呢？但实际确实必须在这里启动
_waiting.push(wt);
}
}
//执行工作线程方法,传入data对象唤醒线程进行工作
public void performedWork(Object data)throws InstantiationException, IllegalAccessException{
WorkerThread w= null;
synchronized(_waiting){
if(_waiting.empty()){
w=new WorkerThread("addtional thread",
(Worker)_workerClass.newInstance());
w.start();
}
else {
w=(WorkerThread)_waiting.pop();
//w.start(); //这条语句是错的，会引发一个IllegalThreadStateException异常，具体原因我也不清楚，你想清楚了，可以告诉我
//在这里启动可能就会导致wake方法失去意义，因为唤醒线程之前必须处于阻塞状态，也就是必须启动线程！在这里启动并不会立即启动
//线程，而是会继续往下执行wake方法，由于线程未启动就唤醒就会出错！
}
w.wake(data);
}
}
@SuppressWarnings("unchecked")
public boolean push(WorkerThread obj){
boolean isPOP=false;
synchronized(_waiting){
if(_waiting.size()<_max){
_waiting.push(obj);
isPOP=true;
}
}
return isPOP;
}
}
interface Worker {
public void run(Object data);
}
