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

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

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

ThreadPool.java

package org.loon.framework.util.test;

import java.util.LinkedList;

import java.util.List;

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;

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;

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

}

}

标签：

本站文章除注明转载外，均为本站原创或翻译。欢迎任何形式的转载，但请务必注明出处、不得修改原文相关链接，尊重他人劳动成果

文章转载自：网络转载

0

好文不易，鼓励一下吧！