我們大家都知道，在處理多線程服務并發時，由于建立線程需要占用很多的系統資源，是以為了避免這些不必要的損耗，通常我們采用線程池來解決這些問題。
線程池的基本原理是，首先建立并保持一定數量的線程，當需要使用線程時，我們從池中取得線程，再将需要運作的任務交給線程進行處理，當任務完成後再将其釋放回池中。
下面，我給出一個很簡單的實作模型，僅供參考。
ThreadPool.java
package org.loon.framework.util.test;
import java.util.LinkedList;
import java.util.List;
/** *//**
* <p>
* Title: LoonFramework
* </p>
* Description:
* Copyright: Copyright (c) 2007
* Company: LoonFramework
*
* @author chenpeng
* @email：[email][email protected][/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);
case Thread.MAX_PRIORITY:
this._idxThreads[PRIORITY_HIGH].add(repool);
default:
throw new IllegalStateException("沒有此種級别");
// 通知所有線程
notifyAll();
} else ...{
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;
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);
case PRIORITY_NORMAL:
thread.setPriority(Thread.NORM_PRIORITY);
case PRIORITY_HIGH:
thread.setPriority(Thread.MAX_PRIORITY);
default:
thread.setPriority(Thread.NORM_PRIORITY);
//啟動
thread.start();
* 傳回線程數量
public int getThreadsCount() ...{
return this._threadCount;
}
Pooled.java:
public class Pooled extends Thread ...{
private ThreadPool _pool;
private Runnable _target;
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) ...{
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());
public synchronized void setTarget(Runnable target) ...{
public synchronized void shutDown() ...{
this._shutdown = true;
測試用類：
* <p>Title: LoonFramework</p>
* <p>Description:線程池測試</p>
* <p>Copyright: Copyright (c) 2007</p>
* <p>Company: LoonFramework</p>
* @author chenpeng
* @email：[email][email protected][/email]
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();
本文轉自 cping 51CTO部落格，原文連結:http://blog.51cto.com/cping1982/130180
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)