如何实现自己的线程池_自己实现线程池

首先，在服务启动的时候，我们可以启动好几个线程，并用一个容器(如线程池)来管理这些线程。当请求到来时，可以从池中取一个线程出来，执行任务(通常是对请求的响应)，当任务结束后，再将这个线程放入池中备用；如果请求到来而池中没有空闲的线程，该请求需要排队等候。最后，当服务关闭时销毁该池即可。

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();

}

}