Código de ejemplo de grupo de subprocesos comunes en Java

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

/**
* 任务分发器
*/
TaskManage de clase pública extiende Thread
{
Vector protegido<Runnable> tareas = nuevo Vector<Runnable>();
funcionamiento booleano protegido = falso;
booleano protegido detenido = falso;
booleano protegido en pausa = falso;
booleano protegido asesinado = falso;
grupo privado ThreadPool;

Gestión de tareas pública (grupo ThreadPool)
{
this.pool = piscina;
}

putTask vacío público (tarea ejecutable)
{
tareas.add(tarea);
}

putTasks vacíos públicos (tareas ejecutables [])
{
para (int i = 0; i < tareas.longitud; i++)
this.tasks.add(tareas[i]);
}

putTasks vacías públicas (tareas de colección <ejecutables>)
{
this.tasks.addAll(tareas);
}

popTask ejecutable protegido()
{
if (tasks.size() > 0) return (Ejecutable) task.remove(0);
de lo contrario, devuelve nulo;
}

booleano público está en ejecución()
{
volver corriendo;
}

tareas de parada públicas vacías ()
{
detenido = verdadero;
}

stopTasksSync público vacío ()
{
detenerTareas();
mientras (está corriendo())
{
intentar
{
dormir(5);
}
captura (Excepción interrumpida e)
{
TaskException.getResultMessage(e);
}
}
}

tareas de pausa públicas vacías ()
{
pausado = verdadero;
}

pausa pública vacíaTasksSync()
{
pausaTareas();
mientras (está corriendo())
{
intentar
{
dormir(5);
}
captura (Excepción interrumpida e)
{
TaskException.getResultMessage(e);
}
}
}

muerte nula pública()
{
si (!ejecutando) interrupción();
más asesinado = verdadero;
}

KillSync público vacío ()
{
matar();
mientras (está vivo())
{
intentar
{
dormir(5);
}
captura (Excepción interrumpida e)
{
TaskException.getResultMessage(e);
}
}
}

startTasks vacías sincronizadas públicas ()
{
corriendo = verdadero;
this.notificar();
}

ejecución vacía sincronizada pública ()
{
intentar
{
mientras (verdadero)
{
si (!ejecutando || tareas.tamaño() == 0)
{
pool.notifyForIdleThread();
this.esperar();
}
demás
{
Tarea ejecutable;
mientras ((tarea = popTask()) != nulo)
{
tarea.run();
si (detenido)
{
detenido = falso;
si (tareas.tamaño() > 0)
{
tareas.clear();
System.out.println(Thread.currentThread().getId() + ": Las tareas se detienen");
romper;
}
}
si (en pausa)
{
pausado = falso;
si (tareas.tamaño() > 0)
{
System.out.println(Thread.currentThread().getId() + ": Las tareas están en pausa");
romper;
}
}
}
corriendo = falso;
}

si (muerto)
{
asesinado = falso;
romper;
}
}
}
captura (Excepción interrumpida e)
{
TaskException.getResultMessage(e);
devolver;
}
}
}

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

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

grupo de subprocesos público()
{
súper();
}

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

inicio público vacío()
{
inicializado = verdadero;
para (int i = 0; i < initPoolSize; i++)
{
Hilo de TaskManage = nuevo TaskManage (este);
hilo.start();
hilos.add(hilo);
}
}

conjunto vacío públicoMaxPoolSize(int maxPoolSize)
{
this.maxPoolSize = maxPoolSize;
if (maxPoolSize < getPoolSize()) setPoolSize(maxPoolSize);
}

/**
* 重设当前线程数 若需杀掉某线程，线程不会立刻杀掉，而会等到线程中的事
* 务处理完成 但此方法会立刻从线程池中移除该线程，不会等待事务处理结束
*/
setPoolSize vacío público (tamaño int)
{
si (!inicializado)
{
initPoolSize = tamaño;
devolver;
}
de lo contrario si (tamaño > getPoolSize())
{
para (int i = getPoolSize(); i < tamaño && i < maxPoolSize; i++)
{
Hilo de TaskManage = nuevo TaskManage (este);
hilo.start();
hilos.add(hilo);
}
}
de lo contrario si (tamaño <getPoolSize())
{
mientras (getPoolSize() > tamaño)
{
TaskManage th = (TaskManage) threads.remove(0);
th.kill();
}
}
}

público int getPoolSize()
{
devolver hilos.size();
}

notificación de anulación protegidaForIdleThread()
{
hasIdleThread = verdadero;
}

waitForIdleThread booleano protegido()
{
hasIdleThread = falso;
mientras (!hasIdleThread && getPoolSize() >= maxPoolSize)
{
intentar
{
Hilo.dormir(5);
}
captura (Excepción interrumpida e)
{
TaskException.getResultMessage(e);
devolver falso;
}
}

devolver verdadero;
}

TaskManage público sincronizado getIdleThread()
{
mientras (verdadero)
{
para (Iterator<TaskManage> itr = threads.iterator(); itr.hasNext();)
{
Administrador de tareas th = (Administrador de tareas) itr.next();
si (!th.isRunning()) devuelve th;
}

si (getPoolSize() < maxPoolSize)
{
Hilo de TaskManage = nuevo TaskManage (este);
hilo.start();
hilos.add(hilo);
hilo de retorno;
}

si (waitForIdleThread() == false) devuelve nulo;
}
}

Tarea de proceso público vacío (tarea ejecutable)
{
Administrador de tareas th = getIdleThread();
si (th! = nulo)
{
th.putTask(tarea);
th.startTasks();
}
}

proceso público vacíoTasksInSingleThread (tareas ejecutables [])
{
Administrador de tareas th = getIdleThread();
si (th! = nulo)
{
th.putTasks(tareas);
th.startTasks();
}
}

proceso público vacíoTasksInSingleThread (tareas de colección <ejecutables>)
{
Administrador de tareas th = getIdleThread();
si (th! = nulo)
{
th.putTasks(tareas);
th.startTasks();
}
}

}

la clase pública TopTask implementa Runnable
{

grupo privado ThreadPool;

tarea superior pública()
{
súper();
}

TopTask pública (grupo ThreadPool)
{
súper();
this.pool = piscina;
}

@Anular
ejecución pública vacía()
{
inicio();
comenzar();
}

/**
* 初始化验证权限、参数之类
*/
inicio público vacío()
{

}

/**
* 开始自动任务
*/
inicio vacío público()
{
para (int i = 0; i < 10; i++)
{
pool.processTask(new BeginAuto());
}
}
}
/**
* 实现类
*/
la clase BeginAuto implementa Runnable
{
@Anular
ejecución pública vacía()
{
System.out.println(Thread.currentThread().getId() + "...................");
}

}