导入java.util.Collection；
导入 java.util.Vector;
/**
* 任务分发器
*/
公共类 TaskManage 扩展 Thread
{
protected Vector<Runnable> 任务 = new Vector<Runnable>();
受保护的布尔运行= false；
受保护的布尔值已停止= false；
受保护的布尔值暂停= false；
受保护的布尔值被杀死= false；
私有ThreadPool池；
公共任务管理（线程池池）
{
this.pool = 池；
}
公共无效putTask（可运行任务）
{
任务.add(任务);
}
公共无效putTasks（Runnable []任务）
{
for (int i = 0; i < 任务.length; i++)
this.tasks.add(tasks[i]);
}
public void putTasks(Collection<Runnable> 任务)
{
this.tasks.addAll(任务);
}
受保护的可运行 popTask()
{
if (tasks.size() > 0) return (Runnable)tasks.remove(0);
否则返回空；
}
公共布尔 isRunning()
{
返回运行；
}
公共无效停止任务（）
{
停止=真；
}
公共无效stopTasksSync（）
{
停止任务（）；
while (正在运行())
{
尝试
{
睡眠（5）；
}
捕获（InterruptedException e）
{
TaskException.getResultMessage(e);
}
}
}
公共无效暂停任务（）
{
暂停=真；
}
公共无效暂停任务同步（）
{
暂停任务（）；
while (正在运行())
{
尝试
{
睡眠（5）；
}
捕获（InterruptedException e）
{
TaskException.getResultMessage(e);
}
}
}
公共无效杀死（）
{
如果（！运行）中断（）；
否则被杀=真；
}
公共无效killSync（）
{
杀（）;
while (isAlive())
{
尝试
{
睡眠（5）；
}
捕获（InterruptedException e）
{
TaskException.getResultMessage(e);
}
}
}
公共同步无效startTasks（）
{
运行=真；
this.notify();
}
公共同步无效运行（）
{
尝试
{
而（真）
{
if (!running ||tasks.size() == 0)
{
pool.notifyForIdleThread();
this.wait();
}
别的
{
可运行的任务；
while ((任务 = popTask()) != null)
{
任务.run();
如果（停止）
{
停止=假；
if (tasks.size() > 0)
{
任务.clear();
System.out.println(Thread.currentThread().getId() + ": 任务已停止");
休息;
}
}
如果（暂停）
{
暂停=假；
if (tasks.size() > 0)
{
System.out.println(Thread.currentThread().getId() + ": 任务已暂停");
休息;
}
}
}
运行=假；
}
如果（被杀）
{
被杀=假；
休息;
}
}
}
捕获（InterruptedException e）
{
TaskException.getResultMessage(e);
返回;
}
}
}
导入java.util.Collection；
导入 java.util.Iterator;
导入 java.util.Vector;
/**
* 线程池
*/
公共类线程池
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
protected Vector<TaskManage> 线程 = new Vector<TaskManage>();
受保护的布尔值初始化= false；
受保护的布尔值 hasIdleThread = false;
公共线程池()
{
极好的（）;
}
公共线程池（int maxPoolSize，int initPoolSize）
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}
公共无效初始化（）
{
初始化=真；
for (int i = 0; i < initPoolSize; i++)
{
TaskManage 线程 = new TaskManage(this);
线程.start();
线程.add(线程);
}
}
公共无效setMaxPoolSize（int maxPoolSize）
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}
/**
* 重设当前线程数若需杀掉某个线程，线程不会立即杀掉，而会等待线程中的事
* 事务处理完成但此方法会重新从线程池中删除该线程，不会等待事务处理结束
*/
公共无效setPoolSize（int大小）
{
if (!初始化)
{
initPoolSize = 大小；
返回;
}
否则如果（大小> getPoolSize（））
{
for (int i = getPoolSize(); i < 大小 && i < maxPoolSize; i++)
{
TaskManage 线程 = new TaskManage(this);
线程.start();
线程.add(线程);
}
}
else if (大小 < getPoolSize())
{
while (getPoolSize() > 大小)
{
TaskManage th = (TaskManage)threads.remove(0);
th.kill();
}
}
}
公共 int getPoolSize()
{
返回线程.size();
}
受保护的无效notifyForIdleThread（）
{
有空闲线程 = true;
}
受保护的布尔 waitForIdleThread()
{
有空闲线程 = false;
while (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
尝试
{
线程.sleep(5);
}
捕获（InterruptedException e）
{
TaskException.getResultMessage(e);
返回假；
}
}
返回真；
}
公共同步任务管理 getIdleThread()
{
而（真）
{
for (Iterator<TaskManage> itr =threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
if (!th.isRunning()) 返回 th;
}
if (getPoolSize() < maxPoolSize)
{
TaskManage 线程 = new TaskManage(this);
线程.start();
线程.add(线程);
返回线程；
}
if (waitForIdleThread() == false) 返回 null;
}
}
公共无效processTask（可运行任务）
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTask(任务);
th.startTasks();
}
}
公共无效processTasksInSingleThread（Runnable []任务）
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTasks(任务);
th.startTasks();
}
}
公共无效 processTasksInSingleThread(Collection<Runnable> 任务)
{
TaskManage th = getIdleThread();
if (th != null)
{
th.putTasks(任务);
th.startTasks();
}
}
}
公共类 TopTask 实现 Runnable
{
私有ThreadPool池；
公共 TopTask()
{
极好的（）;
}
公共TopTask（线程池池）
{
极好的（）;
this.pool = 池；
}
@覆盖
公共无效运行（）
{
初始化（）；
开始（）;
}
/**
* 初始化验证权限、参数之类
*/
公共无效初始化（）
{
}
/**
* 开始自动任务
*/
公共无效开始（）
{
for (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
* 实现类
*/
类 BeginAuto 实现 Runnable
{
@覆盖
公共无效运行（）
{
System.out.println(Thread.currentThread().getId() + ".................");
}
}