JAVA线程池的实现 和 优先级设置

[java]代码库

import java.util.LinkedList;
import java.util.List;

/**
 * 
 * Title: LoonFramework
 * 
 * 
 * Description:
 * 
 * 
 * Copyright: Copyright (c) 2007
 * 
 * 
 * Company: LoonFramework
 * 
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class ThreadPool {

	private static ThreadPool instance = null;

	// 优先级低
	public static final int PRIORITY_LOW = 0;

	// 普通
	public static final int PRIORITY_NORMAL = 1;

	// 高
	public static final int PRIORITY_HIGH = 2;

	// 用以保存空闲连接
	private List[] _idxThreads;

	// 关闭
	private boolean _shutdown = false;

	// 线程数量
	private int _threadCount = 0;

	// debug信息是否输出
	private boolean _debug = false;

	/** */
	/**
	 * 返回ThreadPool实例
	 * 
	 * @return
	 */
	public static ThreadPool getInstance() {
		if (instance == null) {
			instance = new ThreadPool();
		}
		return instance;
	}

	// 初始化线程list
	private ThreadPool() {
		this._idxThreads = new List[] { new LinkedList(), new LinkedList(),
				new LinkedList() };
		this._threadCount = 0;
	}

	/** */
	/**
	 * 同步方法，完成任务后将资源放回线程池中
	 * 
	 * @param repool
	 */
	protected synchronized void repool(Pooled repool) {
		if (this._shutdown) {
			if (this._debug) {
				System.out.println("ThreadPool.repool():重设中……");
			}
			// 优先级别判定
			switch (repool.getPriority()) {
			case Thread.MIN_PRIORITY:
				this._idxThreads[PRIORITY_LOW].add(repool);
				break;
			case Thread.NORM_PRIORITY:
				this._idxThreads[PRIORITY_NORMAL].add(repool);
				break;
			case Thread.MAX_PRIORITY:
				this._idxThreads[PRIORITY_HIGH].add(repool);
				break;
			default:
				throw new IllegalStateException("没有此种级别");
			}
			// 通知所有线程
			notifyAll();

		} else {
			if (this._debug) {
				System.out.println("ThreadPool.repool():注销中……");
			}
			repool.shutDown();
		}
		if (this._debug) {
			System.out.println("ThreadPool.repool():完成");
		}
	}

	public void setDebug(boolean debug) {
		this._debug = debug;
	}

	public synchronized void shutDown() {
		this._shutdown = true;
		if (this._debug) {
			System.out.println("ThreadPool.shutDown():关闭中……");
		}
		for (int index = 0; index <= PRIORITY_NORMAL; index++) {
			List threads = this._idxThreads[index];
			for (int threadIndex = 0; threadIndex < threads.size(); threadIndex++) {
				Pooled idleThread = (Pooled) threads.get(threadIndex);
				idleThread.shutDown();
			}
		}
		notifyAll();
	}

	/** */
	/**
	 * 以指定的优先级启动线程
	 * 
	 * @param target
	 * @param priority
	 */
	public synchronized void start(Runnable target, int priority) {
		Pooled thread = null;
		List idleList = this._idxThreads[priority];
		int idleSize = idleList.size();

		if (idleSize > 0) {
			int lastIndex = idleSize - 1;
			thread = (Pooled) idleList.get(lastIndex);
			idleList.remove(idleList);
			thread.setTarget(target);
		} else {
			this._threadCount++;
			thread = new Pooled(target, "Pooled->" + this._threadCount, this);
			switch (priority) {

			case PRIORITY_LOW:
				thread.setPriority(Thread.MIN_PRIORITY);
				break;
			case PRIORITY_NORMAL:
				thread.setPriority(Thread.NORM_PRIORITY);
				break;
			case PRIORITY_HIGH:
				thread.setPriority(Thread.MAX_PRIORITY);
				break;
			default:
				thread.setPriority(Thread.NORM_PRIORITY);
			}
			// 启动
			thread.start();

		}

	}

	/** */
	/**
	 * 返回线程数量
	 * 
	 * @return
	 */
	public int getThreadsCount() {
		return this._threadCount;
	}

}




/**
 * 
 * Title: LoonFramework
 * 
 * 
 * Description:
 * 
 * 
 * Copyright: Copyright (c) 2007
 * 
 * 
 * Company: LoonFramework
 * 
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class Pooled extends Thread {

	private ThreadPool _pool;

	private Runnable _target;

	private boolean _shutdown = false;

	private boolean _idle = false;

	public Pooled(Runnable target) {
		super(target);
	}

	public Pooled(Runnable target, String name) {
		super(target, name);
	}

	public Pooled(Runnable target, String name, ThreadPool pool) {
		super(name);
		this._pool = pool;
		this._target = target;
	}

	public Pooled(String name) {
		super(name);
	}

	public Pooled(ThreadGroup group, Runnable target) {
		super(group, target);
	}

	public Pooled(ThreadGroup group, Runnable target, String name) {
		super(group, target, name);
	}

	public Pooled(ThreadGroup group, String name) {
		super(group, name);
	}

	public Runnable getTarget() {
		return this._target;
	}

	public boolean isIdle() {
		return this._idle;
	}

	public void run() {
		while (!this._shutdown) {
			this._idle = false;
			if (this._target != null) {
				this._target.run();
			}
			this._idle = true;
			try {

				this._pool.repool(this);

				synchronized (this) {
					wait();
				}

			} catch (InterruptedException ex) {
				System.err.println(ex.getMessage());
			}
			this._idle = false;
		}
	}

	public synchronized void setTarget(Runnable target) {
		this._target = target;
		notifyAll();
	}

	public synchronized void shutDown() {
		this._shutdown = true;
		notifyAll();
	}

}




//测试用类：
package org.loon.framework.util.test;
/** *//**
* Title: LoonFramework 
* Description:线程池测试 
* Copyright: Copyright (c) 2007 
* Company: LoonFramework 
* @author chenpeng  
* @email：ceponline@yahoo.com.cn 
* @version 0.1
*/
public class ThreadPoolTest  {


private static Runnable createRunnable(final int id)  {
    return new Runnable()  {
        public void run()  {
            System.out.println("线程" + id + ",运行 ");
            try  {
                Thread.sleep(1000);
            }
            catch (InterruptedException ex)  { }
            System.out.println("线程" + id + ",结束");
        }
    };
}

public static void main(String[]args) {
    ThreadPool pool=ThreadPool.getInstance();
    pool.setDebug(true);
     for (int i=1; i<=10; i++)  {
         //根据数值，设定不同优先级
         if(i%2==0) {
                 pool.start(createRunnable(i), ThreadPool.PRIORITY_HIGH);
         }else {
                 pool.start(createRunnable(i), ThreadPool.PRIORITY_LOW);
         }
     }
    System.out.println("线程池测试中……");
    System.out.println("线程池线程总数:"+pool.getThreadsCount());
    pool.shutDown();
}
}