线程池的实现

自己实现了一个简单的线程池。希望回复者讨论技术问题，不要说都已经有了，你还重复造轮子。

我的目的是讨论线程池的实现，而不是提供使用。

 

测试代码：

package threadpool;

import ojadb.core.thread.OjadbThreadPool;
import ojadb.core.thread.task.OjadbTask;
import ojadb.exception.OjadbException;

public class BasicTest {
	public static void main(String[] ojadbs) throws OjadbException {
		OjadbThreadPool pool = new OjadbThreadPool(5, 10);
		OjadbTask thread = new OjadbTask("test thread");
		pool.excute(thread);
		System.exit(0);
	}
}

 

线程池：

package ojadb.core.thread;

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import ojadb.core.thread.task.OjadbTask;
import ojadb.core.thread.thread.OjadbThread;
import ojadb.exception.OjadbException;

public class OjadbThreadPool {
	private int minimum;
	private int maximum;
	private LinkedBlockingQueue<OjadbThread> ojadbThreads;
	private BlockingQueue<OjadbTask> ojadbTasks;

	public OjadbThreadPool(int min, int max) throws OjadbException {
		if (0 < min && min < max) {
			minimum = min;
			maximum = max;
			ojadbThreads = new LinkedBlockingQueue<OjadbThread>();
			ojadbTasks = new LinkedBlockingQueue<OjadbTask>();
			for (int i = 0; i < minimum; i++) {
				OjadbThread worker = new OjadbThread(this, "worker" + i);
				worker.start();
			}
		} else {
			throw new OjadbException("无法建立线程池: 最小值必须大于零,小于最大值");
		}
	}

	public void addWorker(OjadbThread ojadbThreadWorker) {
		ojadbThreads.offer(ojadbThreadWorker);
	}

	public void excute(OjadbTask thread) {
		// 生产任务
		ojadbTasks.offer(thread);

		OjadbThread worker = ojadbThreads.remove();
		if (worker != null) {
			worker.work();
		} else if (ojadbThreads.size() < maximum) {
			OjadbThread newWorker = new OjadbThread(this, "worker" + ojadbThreads.size());
			newWorker.start();
		} else {

		}
		releaseThreads();
	}

	private void releaseThreads() {
		while (ojadbThreads.size() > minimum) {
			OjadbThread worker = ojadbThreads.remove();
			System.out.println(worker + "is killed");
			worker.kill();
		}
	}

	public OjadbTask getTask() {
		if (ojadbTasks.size() == 0)
			return null;
		// 消费任务
		return ojadbTasks.remove();
	}
}

 

内部线程：

package ojadb.core.thread.thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

import ojadb.core.thread.OjadbThreadPool;
import ojadb.core.thread.task.OjadbTask;

public class OjadbThread extends Thread {
	private boolean isActived;
	private ReentrantLock lock = new ReentrantLock();
	private Condition condition = lock.newCondition();
	private OjadbThreadPool pool;

	public OjadbThread(OjadbThreadPool pool, String threadName) {
		super(threadName);
		this.pool = pool;
		isActived = true;
	}

	@Override
	public synchronized void start() {
		super.start();
	}

	@Override
	public void run() {
		try {
			lock.lock();

			while (isActived) {
				OjadbTask task = pool.getTask();
				if (task != null) {
					String result = (String) task.excute();

					if (result.length() > 0) {
						pool.addWorker(this);
						// 懒工人策略 -- 没人招呼工作，绝不睡醒
						condition.await();
					}
				} else {
					pool.addWorker(this);
					condition.await();
				}
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}

	public void work() {
		try {
			lock.lock();
			condition.signal();
		} finally {
			lock.unlock();
		}
	}

	public void kill() {
		isActived = false;
		work();
	}

	@Override
	public String toString() {
		return getName();
	}
}

 

用户线程：

package ojadb.core.thread.task;

public class OjadbTask {
	private String threadName;

	public OjadbTask(String threadName) {
		this.threadName = threadName;
	}

	public Object excute() {
		System.out.println("excuting " + threadName);
		return "success";
	}

	public String getName() {
		return threadName;
	}

	public String toString() {
		return threadName;
	}
}