JAVA线程池的简单实现及优先级设置
2010-08-05 20:51
375 查看
转帖:http://www.etest8.com/html/125984.html
我们大家都知道,在处理多线程服务并发时,由于创建线程需要占用很多的系统资源,所以为了避免这些不必要的损耗,通常我们采用线程池来解决这些问题。
线程池的基本原理是,首先创建并保持一定数量的线程,当需要使用线程时,我们从池中取得线程,再将需要运行的任务交给线程进行处理,当任务完成后再将其释放回池中。
下面,我给出一个很简单的实现模型,仅供参考。
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: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;
/** */ /**
*
* Title: LoonFramework
*
*
* Description:
*
*
* Copyright: Copyright (c) 2007
*
*
* Company: LoonFramework
*
*
*/
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
*/
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();
}
转帖:http://www.etest8.com/html/125984.html
我们大家都知道,在处理多线程服务并发时,由于创建线程需要占用很多的系统资源,所以为了避免这些不必要的损耗,通常我们采用线程池来解决这些问题。
线程池的基本原理是,首先创建并保持一定数量的线程,当需要使用线程时,我们从池中取得线程,再将需要运行的任务交给线程进行处理,当任务完成后再将其释放回池中。
下面,我给出一个很简单的实现模型,仅供参考。
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: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;
/** */ /**
*
* Title: LoonFramework
*
*
* Description:
*
*
* Copyright: Copyright (c) 2007
*
*
* Company: LoonFramework
*
*
*/
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
*/
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();
}
转帖:http://www.etest8.com/html/125984.html
相关文章推荐
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的简单实现及优先级设置
- JAVA线程池的实现 和 优先级设置
- JAVA线程池的简单实现及优先级设置[转]
- JAVA线程池的简单实现及优先级设置[转]
- win7 简单设置让单账号实现多台电脑上网(转)
- Android编程实现简单设置按钮颜色的方法
- 权限设置页面之间PK用户体验(功能是否合理?操作是否方便?编程实现是否简单?)
- 打印的简单实现,以及更改打印设置
- 设置ViewPager的切换动画简单的实现
- Asp.net简单代码设置GridView自适应列宽不变形实现思路与代码
- 简单利用Support包中的ScrimInsetsFrameLayout,实现状态栏高度捕获和设置颜色
- Android简单的可设置间隔评分条的实现
- 简单实现设置Gridview默认选中状态
- vb简单实现运算符优先级的计算器