概述
我们大家都知道，在处理多线程服务并发时，由于创建线程需要占用很多的系统资源，所以为了避免这些不必要的损耗，通常我们采用线程池来解决这些问题。
线程池的基本原理是，首先创建并保持一定数量的线程，当需要使用线程时，我们从池中取得线程，再将需要运行的任务交给线程进行处理，当任务完成后再将其释放回池中。
下面，我给出一个很简单的实现模型，仅供参考。
ThreadPool.java
package
org.loon.framework.util.test;
import
java.util.LinkedList;
import
java.util.List;
/**
* <p> * Title: LoonFramework * </p> * <p> * Description: * </p> * <p> * Copyright: Copyright (c) 2007 * </p> * <p> * Company: LoonFramework * </p> * * @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; }}
Pooled.java:
package
org.loon.framework.util.test;
/** * <p> * Title: LoonFramework * </p> * <p> * Description: * </p> * <p> * Copyright: Copyright (c) 2007 * </p> * <p> * Company: LoonFramework * </p> * * @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;
/** * <p>Title: LoonFramework</p> * <p>Description:线程池测试</p> * <p>Copyright: Copyright (c) 2007</p> * <p>Company: LoonFramework</p> * @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(); }}
最后
以上就是单薄发箍为你收集整理的JAVA线程池的简单实现及优先级设置的全部内容，希望文章能够帮你解决JAVA线程池的简单实现及优先级设置所遇到的程序开发问题。
如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。
发表评论 取消回复