Пример кода общего пула потоков в Java

импортировать java.util.Collection;
импортировать java.util.Vector;

/**
* 任务分发器
*/
публичный класс TaskManage расширяет поток
{
защищенные задачи Vector<Runnable> = новый Vector<Runnable>();
защищенное логическое значение = false;
защищенное логическое значение остановлено = ложь;
защищенное логическое значение пауза = ложь;
защищенное логическое значение убит = ложь;
частный пул ThreadPool;

общедоступный TaskManage (пул ThreadPool)
{
this.pool = пул;
}

public void putTask (Выполняемая задача)
{
задачи.добавить(задача);
}

public void putTasks (Задачи Runnable [])
{
for (int i = 0; я <задачи.длина; я++)
this.tasks.add(задачи[я]);
}

public void putTasks (задачи Collection<Runnable>)
{
this.tasks.addAll(задачи);
}

защищенный Runnable popTask()
{
if (tasks.size() > 0) return (Runnable) Tasks.remove(0);
иначе вернуть ноль;
}

публичное логическое значение isRunning()
{
возвратный бег;
}

общественная недействительность stopTasks()
{
остановлен = правда;
}

общественная недействительность stopTasksSync()
{
стопЗадачи();
пока (isRunning())
{
пытаться
{
спать(5);
}
улов (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

общественная недействительность паузы ()
{
пауза = правда;
}

общественная недействительность паузыTasksSync()
{
паузаЗадачи();
пока (isRunning())
{
пытаться
{
спать(5);
}
улов (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

публичное недействительное убийство()
{
если (!работает) прерывание();
еще убито = правда;
}

общественная недействительность killSync()
{
убийство();
пока (isAlive())
{
пытаться
{
спать(5);
}
улов (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

публичный синхронизированный void startTasks()
{
работает = правда;
это.уведомить();
}

общедоступный синхронизированный недействительный запуск()
{
пытаться
{
пока (правда)
{
if (!running || Tasks.size() == 0)
{
пул.notifyForIdleThread();
это.ожидание();
}
еще
{
Выполняемая задача;
while ((task = popTask()) != null)
{
задача.запуск();
если (остановлено)
{
остановлен = ложь;
если (tasks.size() > 0)
{
задачи.очистить();
System.out.println(Thread.currentThread().getId() + ": Задачи остановлены");
перерыв;
}
}
если (пауза)
{
пауза = ложь;
если (tasks.size() > 0)
{
System.out.println(Thread.currentThread().getId() + ": Задачи приостановлены");
перерыв;
}
}
}
работает = ложь;
}

если (убит)
{
убит = ложь;
перерыв;
}
}
}
улов (InterruptedException e)
{
TaskException.getResultMessage(e);
возвращаться;
}
}
}

импортировать java.util.Collection;
импортировать java.util.Iterator;
импортировать java.util.Vector;

/**
* 线程池
*/
общедоступный класс ThreadPool
{
protected int maxPoolSize = TaskConfig.maxPoolSize;
protected int initPoolSize = TaskConfig.initPoolSize;
защищенные потоки Vector<TaskManage> = новый Vector<TaskManage>();
защищенное логическое значение инициализировано = ложь;
защищенное логическое значение hasIdleThread = false;

общедоступный пул потоков()
{
супер();
}

public ThreadPool (int maxPoolSize, int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}

публичная недействительная инициализация()
{
инициализирован = правда;
for (int я = 0; я <initPoolSize; я++)
{
Поток TaskManage = новый TaskManage (это);
поток.start();
threads.add(поток);
}
}

общественная недействительность setMaxPoolSize (int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
если (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* 重设当前线程数若需杀掉某线程,线程不会立刻杀掉,而会等到线程中的事
* 务处理完成但此方法会立刻从线程池中移除该线程,不会等待事务处理结束
*/
public void setPoolSize (размер int)
{
если (!инициализировано)
{
initPoolSize = размер;
возвращаться;
}
иначе, если (размер > getPoolSize())
{
for (int i = getPoolSize(); i < size && i < maxPoolSize; i++)
{
Поток TaskManage = новый TaskManage (это);
поток.start();
threads.add(поток);
}
}
иначе, если (размер < getPoolSize())
{
пока (getPoolSize() > размер)
{
TaskManage th = (TaskManage) threads.remove(0);
TH.kill();
}
}
}

публичный int getPoolSize()
{
вернуть потоки.размер();
}

защищенный void notifyForIdleThread()
{
hasIdleThread = правда;
}

защищенное логическое значение waitForIdleThread()
{
hasIdleThread = ложь;
while (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
пытаться
{
Thread.sleep(5);
}
улов (InterruptedException e)
{
TaskException.getResultMessage(e);
вернуть ложь;
}
}

вернуть истину;
}

общедоступный синхронизированный TaskManage getIdleThread()
{
пока (правда)
{
for (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
if (!th.isRunning()) возвращает th;
}

если (getPoolSize() < maxPoolSize)
{
Поток TaskManage = новый TaskManage (это);
поток.start();
threads.add(поток);
возвратная нить;
}

если (waitForIdleThread() == false) вернуть ноль;
}
}

public void ProcessTask (Выполняемая задача)
{
TaskManage th = getIdleThread();
если (th != ноль)
{
th.putTask(задача);
th.startTasks();
}
}

public void ProcessTasksInSingleThread (Задачи Runnable [])
{
TaskManage th = getIdleThread();
если (th != ноль)
{
th.putTasks(задачи);
th.startTasks();
}
}

public void ProcessTasksInSingleThread (задачи Collection<Runnable>)
{
TaskManage th = getIdleThread();
если (th != ноль)
{
th.putTasks(задачи);
th.startTasks();
}
}

}

публичный класс TopTask реализует Runnable
{

частный пул ThreadPool;

общедоступная ТопТаск()
{
супер();
}

общедоступный TopTask (пул ThreadPool)
{
супер();
this.pool = пул;
}

@Override
публичный недействительный запуск()
{
инициализация();
начинать();
}

/**
* 初始化验证权限、参数之类
*/
публичная недействительная инициализация()
{

}

/**
* 开始自动任务
*/
публичное недействительное начало()
{
для (int я = 0; я <10; я++)
{
Pool.processTask(новый BeginAuto());
}
}
}
/**
* 实现类
*/
класс BeginAuto реализует Runnable
{
@Override
публичный недействительный запуск()
{
System.out.println(Thread.currentThread().getId() + "...................");
}

}