Código de exemplo de pool de threads comuns em java

importar java.util.Collection;
importar java.util.Vector;

/**
* 任务分发器
*/
classe pública TaskManage estende Thread
{
vector protegido<Runnable> tarefas = new Vector<Runnable>();
booleano protegido em execução = falso;
booleano protegido parado = falso;
booleano protegido pausado = falso;
booleano protegido morto = falso;
pool ThreadPool privado;

TaskManage público (conjunto ThreadPool)
{
isto.pool = piscina;
}

public void putTask (tarefa executável)
{
tarefas.add(tarefa);
}

public void putTasks(tarefas executáveis[])
{
for (int i = 0; i <tarefas.comprimento; i++)
this.tasks.add(tarefas[i]);
}

public void putTasks(Tarefas de coleção<Runnable>)
{
this.tasks.addAll(tarefas);
}

popTask executável protegido()
{
if (tasks.size() > 0) return (Executável) tasks.remove(0);
caso contrário, retorne nulo;
}

booleano público isRunning()
{
retornar correndo;
}

public void stopTasks()
{
parado = verdadeiro;
}

public void stopTasksSync()
{
stopTasks();
enquanto (isRunning())
{
tentar
{
dormir(5);
}
pegar (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

public void pauseTasks()
{
pausado = verdadeiro;
}

pausa nula públicaTasksSync()
{
pauseTasks();
enquanto (isRunning())
{
tentar
{
dormir(5);
}
pegar (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

matar vazio público ()
{
if (!em execução)interrupção();
senão morto = verdadeiro;
}

public void killSync()
{
matar();
enquanto (isAlive())
{
tentar
{
dormir(5);
}
pegar (InterruptedException e)
{
TaskException.getResultMessage(e);
}
}
}

público sincronizado void startTasks()
{
correndo = verdadeiro;
this.notify();
}

execução nula sincronizada pública()
{
tentar
{
enquanto (verdadeiro)
{
if (!em execução || tarefas.size() == 0)
{
pool.notifyForIdleThread();
this.wait();
}
outro
{
Tarefa executável;
while ((tarefa = popTask()) != nulo)
{
tarefa.run();
se (parado)
{
parado = falso;
if (tarefas.size() > 0)
{
tarefas.clear();
System.out.println(Thread.currentThread().getId() + ": As tarefas foram interrompidas");
quebrar;
}
}
se (pausado)
{
pausado = falso;
if (tarefas.size() > 0)
{
System.out.println(Thread.currentThread().getId() + ": As tarefas estão pausadas");
quebrar;
}
}
}
correndo = falso;
}

se (morto)
{
morto = falso;
quebrar;
}
}
}
pegar (InterruptedException e)
{
TaskException.getResultMessage(e);
retornar;
}
}
}

importar java.util.Collection;
importar java.util.Iterator;
importar java.util.Vector;

/**
* 线程池
*/
classe pública ThreadPool
{
protegido int maxPoolSize = TaskConfig.maxPoolSize;
protegido int initPoolSize = TaskConfig.initPoolSize;
threads Vector<TaskManage> protegidos = new Vector<TaskManage>();
booleano protegido inicializado = falso;
hasIdleThread booleano protegido = false;

ThreadPool público()
{
super();
}

ThreadPool público(int maxPoolSize, int initPoolSize)
{
this.maxPoolSize = maxPoolSize;
this.initPoolSize = initPoolSize;
}

inicialização pública nula()
{
inicializado = verdadeiro;
for (int i = 0; i < initPoolSize; i++)
{
Thread TaskManage = novo TaskManage (este);
thread.start();
threads.add(thread);
}
}

public void setMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize <getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* 重设当前线程数 若需杀掉某线程，线程不会立刻杀掉，而会等到线程中的事
* 务处理完成 但此方法会立刻从线程池中移除该线程，不会等待事务处理结束
*/
public void setPoolSize(tamanho interno)
{
se (! inicializado)
{
initPoolSize = tamanho;
retornar;
}
senão if (tamanho > getPoolSize())
{
for (int i = getPoolSize(); i < tamanho && i < maxPoolSize; i++)
{
Thread TaskManage = novo TaskManage (este);
thread.start();
threads.add(thread);
}
}
senão if (tamanho <getPoolSize())
{
while (getPoolSize() > tamanho)
{
TaskManage th = (TaskManage) threads.remove(0);
th.kill();
}
}
}

público int getPoolSize()
{
retornar threads.size();
}

notificação nula protegidaForIdleThread()
{
hasIdleThread = verdadeiro;
}

booleano protegido waitForIdleThread()
{
hasIdleThread = falso;
enquanto (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
tentar
{
Thread.sleep(5);
}
pegar (InterruptedException e)
{
TaskException.getResultMessage(e);
retornar falso;
}
}

retornar verdadeiro;
}

TaskManage getIdleThread() sincronizado público
{
enquanto (verdadeiro)
{
for (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
TaskManage th = (TaskManage) itr.next();
if (!th.isRunning()) retornar th;
}

if (getPoolSize() <maxPoolSize)
{
Thread TaskManage = novo TaskManage (este);
thread.start();
threads.add(thread);
thread de retorno;
}

if (waitForIdleThread() == false) retornar nulo;
}
}

public void processTask (tarefa executável)
{
TaskManage th = getIdleThread();
if (th! = nulo)
{
th.putTask(tarefa);
th.startTasks();
}
}

public void processTasksInSingleThread(Tarefas executáveis[])
{
TaskManage th = getIdleThread();
if (th! = nulo)
{
th.putTasks(tarefas);
th.startTasks();
}
}

public void processTasksInSingleThread(Coleção<Runnable> tarefas)
{
TaskManage th = getIdleThread();
if (th! = nulo)
{
th.putTasks(tarefas);
th.startTasks();
}
}

}

classe pública TopTask implementa Runnable
{

pool ThreadPool privado;

TopTask pública()
{
super();
}

TopTask público (conjunto ThreadPool)
{
super();
isto.pool = piscina;
}

@Substituir
execução de vazio público ()
{
iniciar();
começar();
}

/**
* 初始化验证权限、参数之类
*/
inicialização pública nula()
{

}

/**
* 开始自动任务
*/
início vazio público()
{
para (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
* 实现类
*/
classe BeginAuto implementa Runnable
{
@Substituir
execução de vazio público ()
{
System.out.println(Thread.currentThread().getId() + "...................");
}

}