用java实现一个线程连接池

线程池:

import java.util.LinkedList;

public abstract class Manager {

private String mThreadPoolName = null;

private int mThreadPoolMaxSize = 1;

private LinkedList workers = new LinkedList();

public Manager() {
}

public Manager(String name, int poolMaxSize) {
mThreadPoolName = name;
createWorker(name, poolMaxSize);
mThreadPoolMaxSize = poolMaxSize;
}

private void createWorker(int poolMaxSize) {
for (int i = 0; i < poolMaxSize; i++) {
Worker worker = new ...Worker(this);
workers.addLast(worker);
}
}

public synchronized Worker getIdleWorker() {
return (Worker)workers.removeFirst();
}

public synchronized void notifyFree(Worker worker) {
if (workers.size() < mThreadPoolMaxSize) {
workers.addLast(worker);
} else {
worker = null;
}
}

public int getThreadPoolMaxSize() {
return mThreadPoolMaxSize;
}

public void setThreadPoolMaxSize(int threadPoolMaxSize) {
this.mThreadPoolMaxSize = threadPoolMaxSize;
}

}

线程抽象类

public abstract class Worker implements Runnable {

private Manager mManager = null;

private Thread mThread = null;

public Worker() {
}

public Worker(String threadName, Manager manager) {
mManager = manager;
mThread = new Thread(this, threadName);
init();
mThread.start();
}

public abstract void init();

public void run() {
while (true) {
waitForStart();
Worker worker = mManager.getIdleWorker();
process();
isRunning = false;
mManager.notifyFree(worker);
}
}

public abstract void process();

public void start() {
isRunning = true;
mManager.getIdleWorker();
notifyToStart();
}

public synchronized void waitForStart() {
try {
wait();
} catch (InterruptedException ex) {
}
}

public synchronized void notifyToStart() {
notify();
}

}