java shutdown 优先级_JAVA线程池的简单实现及优先级设置

我们大家都知道，在处理多线程服务并发时，由于创建线程需要占用很多的系统资源，所以为了避免这些不必要的损耗，通常我们采用线程池来解决这些问题。

线程池的基本原理是，首先创建并保持一定数量的线程，当需要使用线程时，我们从池中取得线程，再将需要运行的任务交给线程进行处理，当任务完成后再将其释放回池中。

下面，我给出一个很简单的实现模型，仅供参考。

ThreadPool.java

package org.loon.framework.util.test;

import java.util.LinkedList;

import java.util.List;

/** *//**

*

* Title: LoonFramework

*

*

* Description:

*

*

* Copyright: Copyright (c) 2007

*

*

* Company: LoonFramework

*

*

* @author chenpeng

* @email：[email]ceponline@yahoo.com.cn[/email]

* @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

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;

/** *//**

*

* Title: LoonFramework

*

*

* Description:

*

*

* Copyright: Copyright (c) 2007

*

*

* Company: LoonFramework

*

*

* @author chenpeng

* @email：[email]ceponline@yahoo.com.cn[/email]

* @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：[email]ceponline@yahoo.com.cn[/email]

* @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();

}

}