首先,在服務啟動的時候,我們可以啟動好幾個執行緒,並用一個容器(如執行緒池)來管理這些執行緒。當請求到來時,可以從池中取一個執行緒出來,執行任務(通常是對請求的響應),當任務結束後,再將這個執行緒放入池中備用;如果請求到來而池中沒有空閒的執行緒,該請求需要排隊等候。最後,當服務關閉時銷燬該池即可。

public interface Pool {

//獲取工作執行緒

public abstract PoolWorker getPoolWorker();

//銷燬工作執行緒

public abstract void destroy();

}

public interface PoolWorker {

public abstract void setTask(Task task);

public abstract Task getTask();

public abstract void startTask();

}

public class Task {

public void execute() {

System.out.println("執行任務");

}

}

public class ThreadPoolManager implements Pool {

private boolean isShut;

private int size;

private LinkedList<PoolWorker> poolWorkers;

private class PoolWorkerImpl extends Thread implements PoolWorker {

private Task task;

private Object obj = new Object();

@Override

public void setTask(Task task) {

this.task = task;

}

@Override

public Task getTask() {

return this.task;

}

@Override

public void startTask() {

synchronized (obj) {

obj.notify();

}

}

public void run() {

while (!isShut) {

synchronized (obj) {

try {

obj.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

 

}

getTask().execute();

synchronized (poolWorkers) {

poolWorkers.addFirst(PoolWorkerImpl.this);

poolWorkers.notifyAll();

}

}

 

}

}

public ThreadPoolManager(int size) {

this.size = size;

isShut = false;

poolWorkers = new LinkedList<PoolWorker>();

for (int i = 0; i < size; i++) {

PoolWorker poolWorker = new PoolWorkerImpl();

poolWorkers.add(poolWorker);

// 向下轉型,以便可以使用子類獨有的方法

((PoolWorkerImpl) poolWorker).start();

}

}

@Override

public PoolWorker getPoolWorker() {

PoolWorker poolWorker = null;

synchronized (poolWorkers) {

if (poolWorkers.size() > 0) {

poolWorker = poolWorkers.removeFirst();

} else {

try {

poolWorkers.wait();

} catch (InterruptedException e) {

e.printStackTrace();

}

poolWorker = poolWorkers.removeFirst();

}

}

return poolWorker;

}

@Override

public void destroy() {

isShut = true;

poolWorkers.notifyAll();

poolWorkers.clear();

}

}