一个简单的线程池实现（java版）（转）

1 线程池代码： 

package org.biao.threadpool;

import java.util.List;
import java.util.Vector;

//线程池，其实就是一些队列操作
public class ThreadPool {
	private static ThreadPool instance_ = null;
	// 定义优先级别常数，空闲的线程按照优先级不同分别存放在三个vector中
	public static final int LOW_PRIORITY = 0;
	public static final int NORMAL_PRIORITY = 1;
	public static final int HIGH_PRIORITY = 2;
	// 保存空闲线程的List，或者说它是"池"
	private List<PooledThread>[] idleThreads_;
	private boolean shutDown_ = false;
	private int threadCreationCounter_; // 以创建的线程的个数
	private boolean debug_ = false; // 是否输出调试信息

	// 构造函数，因为这个类视作为singleton实现的，因此构造函数为私有
	private ThreadPool() {
		// 产生空闲线程.三个vector分别存放分别处在三个优先级的线程的引用
		List[] idleThreads = { new Vector(5), new Vector(5), new Vector(5) };
		idleThreads_ = idleThreads;
		threadCreationCounter_ = 0;
	}

	public int getCreatedThreadsCount() {
		return threadCreationCounter_;
	}

	// 通过这个函数得到线程池类的实例
	public static ThreadPool instance() {
		if (instance_ == null)
			instance_ = new ThreadPool();
		return instance_;
	}

	public boolean isDebug() {
		return debug_;
	}

	// 将线程repoolingThread从新放回到池中，这个方式是同步方法。
	// 这个方法会在多线程的环境中调用，设计这个方法的目的是让工作者线程
	// 在执行完target中的任务后，调用池类的repool()方法，
	// 将线程自身从新放回到池中。只所以这么做是因为线程池并不能预见到
	// 工作者线程何时会完成任务。参考PooledThread的相关代码。
	protected synchronized void repool(PooledThread repoolingThread) {
		if (!shutDown_) {
			if (debug_) {
				System.out.println("ThreadPool.repool() : repooling ");
			}
			switch (repoolingThread.getPriority()) {
			case Thread.MIN_PRIORITY: {
				idleThreads_[LOW_PRIORITY].add(repoolingThread);
				break;
			}
			case Thread.NORM_PRIORITY: {
				idleThreads_[NORMAL_PRIORITY].add(repoolingThread);
				break;
			}
			case Thread.MAX_PRIORITY: {
				idleThreads_[HIGH_PRIORITY].add(repoolingThread);
				break;
			}
			default:
				throw new IllegalStateException(
						"Illegal priority found while repooling a Thread!");
			}
			notifyAll();// 通知所有的线程
		} else {
			if (debug_) {
				System.out
						.println("ThreadPool.repool() : Destroying incoming thread.");
			}
			repoolingThread.shutDown();// 关闭线程
		}
		if (debug_) {
			System.out.println("ThreadPool.recycle() : done.");
		}
	}

	public void setDebug(boolean newDebug) {
		debug_ = newDebug;
	}

	// 停止池中所有线程
	public synchronized void shutdown() {
		shutDown_ = true;
		if (debug_) {
			System.out.println("ThreadPool : shutting down ");
		}
		for (int prioIndex = 0; prioIndex <= HIGH_PRIORITY; prioIndex++) {
			List prioThreads = idleThreads_[prioIndex];
			for (int threadIndex = 0; threadIndex < prioThreads.size(); threadIndex++) {
				PooledThread idleThread = (PooledThread) prioThreads
						.get(threadIndex);
				idleThread.shutDown();
			}
		}
		notifyAll();
		if (debug_) {
			System.out.println("ThreadPool : shutdown done.");
		}
	}

	// 以Runnable为target，从池中选择一个优先级为priority的线程创建线程
	// 并让线程运行。
	public synchronized void start(Runnable target, int priority) {
		PooledThread thread = null; // 被选出来执行target的线程
		List idleList = idleThreads_[priority];
		if (idleList.size() > 0) {
			// 如果池中相应优先级的线程有空闲的，那么从中取出一个
			// 设置它的target，并唤醒它
			// 从空闲的线程队列中获取
			int lastIndex = idleList.size() - 1;
			thread = (PooledThread) idleList.get(lastIndex);
			idleList.remove(lastIndex);
			thread.setTarget(target);
		}
		// 池中没有相应优先级的线程
		else {
			threadCreationCounter_++;
			// 创建新线程，
			thread = new PooledThread(target, "PooledThread #"
					+ threadCreationCounter_, this);
			// 新线程放入池中
			switch (priority) {
			case LOW_PRIORITY: {
				thread.setPriority(Thread.MIN_PRIORITY);
				break;
			}
			case NORMAL_PRIORITY: {
				thread.setPriority(Thread.NORM_PRIORITY);
				break;
			}
			case HIGH_PRIORITY: {
				thread.setPriority(Thread.MAX_PRIORITY);
				break;
			}
			default: {
				thread.setPriority(Thread.NORM_PRIORITY);
				break;
			}
			}
			// 启动这个线程
			thread.start();
		}
	}
}

 

 

2 线程池中等待处理工作任务的线程：

package org.biao.threadpool;

//池里的线程
public class PooledThread extends Thread {
	private ThreadPool pool_; // 池中线程需要知道自己所在的池
	private Runnable target_; // 线程的任务
	private boolean shutDown_ = false;
	private boolean idle_ = false;// 设置是否让线程处于等待状态

	private PooledThread() {
		super();
	}

	private PooledThread(Runnable target) {
		super(target); // 初始化父类
	}

	private PooledThread(Runnable target, String name) {
		super(target, name);
	}

	public PooledThread(Runnable target, String name, ThreadPool pool) {
		super(name);
		pool_ = pool;
		target_ = target;
	}

	private PooledThread(String name) {
		super(name);// 初始化父类
	}

	private PooledThread(ThreadGroup group, Runnable target) {
		super(group, target);
	}

	private PooledThread(ThreadGroup group, Runnable target, String name) {
		super(group, target, name);
	}

	private PooledThread(ThreadGroup group, String name) {
		super(group, name);
	}

	public java.lang.Runnable getTarget() {
		return target_;
	}

	public boolean isIdle() {
		return idle_;// 返回当前的状态
	}

	// 工作者线程与通常线程不同之处在于run()方法的不同。通常的线程，
	// 完成线程应该执行的代码后，自然退出，线程结束。
	// 虚拟机在线程结束后收回分配给线程的资源，线程对象被垃圾回收。]
	// 而这在池化的工作者线程中是应该避免的，否则线程池就失去了意义。
	// 作为可以被放入池中并重新利用的工作者线程，它的run()方法不应该结束，
	// 随意，在随后可以看到的实现中，run()方法执行完target对象的代码后，
	// 就将自身repool()，然后调用wait()方法，使自己睡眠而不是退出循环和run()。
	// 这就使线程池实现的要点。
	public void run() {
		// 这个循环不能结束，除非池类要求线程结束
		// 每一次循环都会执行一次池类分配给的任务target
		while (!shutDown_){
			idle_ = false;
			if (target_ != null){
				target_.run(); // 运行target中的代码
			}//干完活了，将这个线程放入线程池中
			idle_ = true;
			try {
				// 线程通知池重新将自己放回到池中
				pool_.repool(this); // 
				// 进入池中后睡眠，等待被唤醒执行新的任务，
				// 这里是线程池中线程于普通线程的run()不同的地方。
				synchronized (this) {
					wait();
				}
			} catch (InterruptedException ie) {
			}
			idle_ = false;
		}
		// 循环这里不能结束，否则线程结束，资源被VM收回，
		// 就无法起到线程池的作用了
	}

	public synchronized void setTarget(java.lang.Runnable newTarget) {// 设置新的target，并唤醒睡眠中的线程
		target_ = newTarget; // 新任务
		notifyAll(); // 唤醒睡眠的线程
	}

	public synchronized void shutDown() {
		shutDown_ = true;
		notifyAll();
	}
}

 

 

3 测试代码：

package org.biao.threadpool;

public class Test {
	public static void main(String[] args) {
		System.out.println("Testing ThreadPool ");
		System.out.println("Creating ThreadPool ");
		ThreadPool pool = ThreadPool.instance();
		pool.setDebug(true);
		class Worker implements Runnable {//这个才是真正干活的人啊
			public int count = 0;

			public void run() {
				System.out.println("Testrunner sleeping 5 seconds ");
				// 此方法使本线程睡眠5秒
				synchronized (this) {
					try {
						wait(5000);// 等待5秒时间
					} catch (InterruptedException ioe) {
					}
				}
				System.out.println("Testrunner leaving  ");
				count++;
			}
		}
		System.out.println("Starting a new thread ");
		Worker runner = new Worker();
		pool.start(runner, pool.HIGH_PRIORITY);
		System.out.println("count : " + runner.count);
		System.out.println("Thread count : " + pool.getCreatedThreadsCount());
		pool.shutdown();
	}
}

 

测试结果：

Testing ThreadPool
Creating ThreadPool
Starting a new thread
count : 0
Thread count : 1
Testrunner sleeping 5 seconds
ThreadPool : shutting down
ThreadPool : shutdown done.
Testrunner leaving 
ThreadPool.repool() : Destroying incoming thread.
ThreadPool.recycle() : done.