JAVA线程池的简单实现及优先级设置

我们大家都知道，在处理多线程服务并发时，由于创建线程需要占用很多的系统资源，所以为了避免这些不必要的损耗，通常我们采用线程池来解决这些问题。
线程池的基本原理是，首先创建并保持一定数量的线程，当需要使用线程时，我们从池中取得线程，再将需要运行的任务交给线程进行处理，当任务完成后再将其释放回池中。
下面，我给出一个很简单的实现模型，仅供参考。

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>
*
*@authorchenpeng
*@email：[email protected]
*@version0.1
*/
public class ThreadPool ... {

privatestaticThreadPoolinstance=null;

//优先级低
publicstaticfinalintPRIORITY_LOW=0;

//普通
publicstaticfinalintPRIORITY_NORMAL=1;

//高
publicstaticfinalintPRIORITY_HIGH=2;

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

//关闭
privateboolean_shutdown=false;

//线程数量
privateint_threadCount=0;

//debug信息是否输出
privateboolean_debug=false;

/***//**
*返回ThreadPool实例
*
*@return
*/
publicstaticThreadPoolgetInstance()...{
if(instance==null)...{
instance=newThreadPool();
}
returninstance;
}

//初始化线程list
privateThreadPool()...{
this._idxThreads=newList[]...{newLinkedList(),newLinkedList(),
newLinkedList()};
this._threadCount=0;
}

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

}else...{
if(this._debug)...{
System.out.println("ThreadPool.repool():注销中……");
}
repool.shutDown();
}
if(this._debug)...{
System.out.println("ThreadPool.repool():完成");
}
}
publicvoidsetDebug(booleandebug)...{
this._debug=debug;
}
publicsynchronizedvoidshutDown()...{
this._shutdown=true;
if(this._debug)...{
System.out.println("ThreadPool.shutDown():关闭中……");
}
for(intindex=0;index<=PRIORITY_NORMAL;index++)...{
Listthreads=this._idxThreads[index];
for(intthreadIndex=0;threadIndex<threads.size();threadIndex++)...{
PooledidleThread=(Pooled)threads.get(threadIndex);
idleThread.shutDown();
}
}
notifyAll();
}

/***//**
*以指定的优先级启动线程
*@paramtarget
*@parampriority
*/
publicsynchronizedvoidstart(Runnabletarget,intpriority)...{
Pooledthread=null;
ListidleList=this._idxThreads[priority];
intidleSize=idleList.size();

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

casePRIORITY_LOW:
thread.setPriority(Thread.MIN_PRIORITY);
break;
casePRIORITY_NORMAL:
thread.setPriority(Thread.NORM_PRIORITY);
break;
casePRIORITY_HIGH:
thread.setPriority(Thread.MAX_PRIORITY);
break;
default:
thread.setPriority(Thread.NORM_PRIORITY);
}
//启动
thread.start();

}


}

/***//**
*返回线程数量
*
*@return
*/
publicintgetThreadsCount()...{
returnthis._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>
*
*@authorchenpeng
*@email：[email protected]
*@version0.1
*/
public class Pooled extends Thread ... {

privateThreadPool_pool;

privateRunnable_target;

privateboolean_shutdown=false;

privateboolean_idle=false;

publicPooled(Runnabletarget)...{
super(target);
}

publicPooled(Runnabletarget,Stringname)...{
super(target,name);
}

publicPooled(Runnabletarget,Stringname,ThreadPoolpool)...{
super(name);
this._pool=pool;
this._target=target;
}

publicPooled(Stringname)...{
super(name);
}

publicPooled(ThreadGroupgroup,Runnabletarget)...{
super(group,target);
}

publicPooled(ThreadGroupgroup,Runnabletarget,Stringname)...{
super(group,target,name);
}

publicPooled(ThreadGroupgroup,Stringname)...{
super(group,name);
}

publicRunnablegetTarget()...{
returnthis._target;
}

publicbooleanisIdle()...{
returnthis._idle;
}

publicvoidrun()...{
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(InterruptedExceptionex)...{
System.err.println(ex.getMessage());
}
this._idle=false;
}
}

publicsynchronizedvoidsetTarget(Runnabletarget)...{
this._target=target;
notifyAll();
}

publicsynchronizedvoidshutDown()...{
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>
*@authorchenpeng
*@email：[email protected]
*@version0.1
*/
public class ThreadPoolTest ... {


privatestaticRunnablecreateRunnable(finalintid)...{
returnnewRunnable()...{
publicvoidrun()...{
System.out.println("线程"+id+",运行 ");
try...{
Thread.sleep(1000);
}
catch(InterruptedExceptionex)...{}
System.out.println("线程"+id+",结束");
}
};
}

publicstaticvoidmain(String[]args)...{
ThreadPoolpool=ThreadPool.getInstance();
pool.setDebug(true);
for(inti=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();
}
}