Cómo implementar el grupo de subprocesos de Java
Introducción al grupo de subprocesos:
La tecnología de subprocesos múltiples resuelve principalmente el problema de la ejecución de múltiples subprocesos en la unidad del procesador. Puede reducir significativamente el tiempo de inactividad de la unidad del procesador y aumentar el tiempo de inactividad. tasa de utilización de la unidad de procesamiento.
Supongamos que el tiempo necesario para que un servidor complete una tarea es: T1 crea el tiempo del subproceso, T2 ejecuta la tarea en el subproceso y T3 destruye el tiempo del subproceso.
Si: T1 T3 es mucho más grande que T2, puede utilizar un grupo de subprocesos para mejorar el rendimiento del servidor.
Un grupo de subprocesos incluye los siguientes cuatro componentes básicos:
1. Administrador de grupos de subprocesos (ThreadPool): se utiliza para crear y administrar grupos de subprocesos, incluida la creación de grupos de subprocesos y la destrucción de grupos de subprocesos. agregar nuevas tareas;
2. Subproceso de trabajo (PoolWorker): los subprocesos en el grupo de subprocesos están en estado de espera cuando no hay tareas y pueden ejecutar tareas cíclicamente; Interfaz de tareas (Tarea): la interfaz que cada tarea debe implementar para que el hilo de trabajo programe la ejecución de la tarea. Estipula principalmente la entrada de la tarea, el trabajo final después de que se ejecuta la tarea y el estado de ejecución. tarea, etc.;
4. Cola de tareas (taskQueue): se utiliza para almacenar tareas no procesadas. Proporcionar un mecanismo de amortiguación.
La tecnología de grupo de subprocesos es una tecnología que se centra en cómo acortar o ajustar los tiempos T1 y T3, mejorando así el rendimiento del programa del servidor. Organiza T1 y T3 respectivamente en los períodos de inicio y finalización del programa del servidor o en algunos períodos de tiempo inactivo, de modo que cuando el programa del servidor procese las solicitudes de los clientes, no habrá sobrecarga de T1 y T3.
El grupo de subprocesos no solo ajusta el período de tiempo durante el cual se generan T1 y T3, sino que también reduce significativamente la cantidad de subprocesos creados. Mire un ejemplo:
Supongamos. un servidor tiene que manejar 50.000 solicitudes por día y cada solicitud requiere un hilo separado para completarse. En el grupo de subprocesos, la cantidad de subprocesos generalmente es fija, por lo que la cantidad total de subprocesos generados no excederá la cantidad de subprocesos en el grupo de subprocesos. Si el servidor no utiliza el grupo de subprocesos para procesar estas solicitudes, el número total de. Los hilos serán 50.000. El tamaño general del grupo de subprocesos es mucho menor que 50.000. Por lo tanto, el programa de servidor que utiliza el grupo de subprocesos no perderá tiempo procesando solicitudes para crear 50.000, mejorando así la eficiencia.
La interfaz de tareas no se implementa en la implementación del código, pero el objeto Runnable se agrega al administrador del grupo de subprocesos (ThreadPool), y luego el administrador del grupo de subprocesos (ThreadPool) completa el resto del paquete. .util.thread;?
importar?java.util.LinkedList;?
importar?java.util.List;? ?Clase de grupo de subprocesos, administrador de subprocesos: ¿crear subprocesos, ejecutar tareas, destruir subprocesos y obtener información básica de subprocesos */?
public?final?class?ThreadPool?{?
//¿El número predeterminado de subprocesos en el grupo de subprocesos es 5?
private?static?int?worker_num?=?5;?
//?¿Subprocesos de trabajo?
privado?WorkThread[]?workThrads;?
//?¿Tareas no procesadas?
privado?static?volatile?int?finished_task?=?0; /p>
//?Cola de tareas, como búfer, ¿el hilo de lista no es seguro?
private?Listlt;Runnablegt;?taskQueue?=?new?LinkedListlt;Runnablegt;();
private?static?ThreadPool?threadPool;?
//?¿Crear un grupo de subprocesos con el número predeterminado de subprocesos?
private?ThreadPool()? {?
this(5);?
}?
//?Crear un grupo de subprocesos, trabajador_num es el número de subprocesos de trabajo en el grupo de subprocesos. ?
privado?ThreadPool(int?worker_num)?{?
ThreadPool.worker_num?=?worker_num;?
workThrads?=?new?WorkThread[ núm_trabajador] ;?
for?(int?i?=?0;?i?lt;?núm_trabajador;?i )?{?
workThrads[i]?=? new? WorkThread();?
workThrads[i].start();//?¿Iniciar el hilo en el grupo de hilos?
}?
}?
//?Modo monomórfico, ¿obtener un grupo de subprocesos con un número predeterminado de subprocesos?
public?static?ThreadPool?getThreadPool()?{?
return ?getThreadPool(ThreadPool.worker_num);?
}?
//?Modo de estado único, obtiene un grupo de subprocesos con un número específico de subprocesos, trabajador_num(gt ; 0) ¿El número de subprocesos de trabajo en el grupo es el subproceso?
//?worker_numlt;=0 para crear el número predeterminado de subprocesos de trabajo?
public?static?ThreadPool ?getThreadPool(int?worker_num1)? {?
if?(worker_num1?lt;=?0)?
worker_num1?=?ThreadPool
.worker_num;?
si?(threadPool?==?null)?
threadPool?=?new?ThreadPool(worker_num1);?
¿regresar? threadPool;?
}?
//?La ejecución de una tarea en realidad simplemente agrega la tarea a la cola de tareas. ¿Cuándo decide ejecutarla el administrador del grupo de subprocesos?
¿público?void?execute(¿Ejecutable?tarea)?{?
¿sincronizado?(taskQueue)?{?
taskQueue.add(tarea);?
taskQueue.notify();?
}?
}?
//? La ejecución de tareas en lotes en realidad solo agrega las tareas a la tarea. cola. ¿Cuándo la ejecución la determina el administrador del grupo de subprocesos?
public?void?execute(Runnable[]?task)?{?
synchronized?(taskQueue)?{?
para?(¿Ejecutable?t?:?task)?
taskQueue.add(t);?
taskQueue.notify();?
}?
}?
//? La ejecución de tareas en lotes en realidad solo agrega las tareas a la cola de tareas. ¿Cuándo decide el administrador del grupo de subprocesos cuándo ejecutar?
public?void?execute(Listlt;Runnablegt;?task)?{?
¿sincronizado?(taskQueue)?{?
para?(Runnable? t?:?task )?
taskQueue.add(t);?
taskQueue.notify();?
}?
}?
//? ¿Destruir el grupo de subprocesos? ¿Este método garantiza que todos los subprocesos se destruirán solo cuando se completen todas las tareas?
public?void?destroy() ?{?
while?(!taskQueue.isEmpty())?{//?Si todavía hay tareas que no se han completado, ¿por qué no realizar ¿una siesta primero?
¿intentar?{?
Thread.sleep(10);?
}?catch?(InterruptedException?e)?{?
e.printStackTrace();?
}?
}?
//?El hilo de trabajo deja de funcionar y se establece en ¿nulo?
for?(int?i? =?0;?i?lt;?worker_num;?i )?{?
workThrads[i].stopWorker(); ?
workThrads[i]?=?null ;?
}?
threadPool=null;?
taskQueue.clear(
//?¿Borrar la cola de tareas?
}?
//?¿Devolver el número de subprocesos de trabajo?
public?int?getWorkThreadNumber() ?{?
return?worker_num;?
}
//?Devuelve las personas que han completado la tarea
La cantidad de tareas completadas aquí es la cantidad de tareas que solo han salido de la cola de tareas. ¿Quizás la tarea no se ha completado realmente?
public?int?getFinishedTasknumber()?{?
return?finished_task;?
}?
//?¿Devuelve la longitud de la cola de tareas, es decir, la cantidad de tareas que aún no se han procesado?
public?int? getWaitTasknumber()?{?
return?taskQueue.size();?
}
//? Anule el método toString y devuelva la información del grupo de subprocesos: ¿Número de subprocesos de trabajo y número de tareas completadas?
@Override?
public?String?toString()?{?
regresar?"WorkThread? número: "? ?worker_num? ??terminado?tarea?número: "?
?terminado_tarea? ??esperar?tarea?número: "? getWaitTasknumber();?
}?
/**? *?Clase interna, hilo de trabajo */?
¿clase privada?WorkThread?extiende ?Subproceso?{?
//?¿El subproceso de trabajo es válido y se utiliza para finalizar el subproceso de trabajo?
privado?boolean?isRunning?=?true;?
/*? *?La clave es Ah, si la cola de tareas no está vacía, saque la tarea y ejecútela. Si la cola de tareas está vacía, espere */?
@Override. ?
public?void?run()?{ ?
¿Ejecutable?r?=?null;?
mientras?(isRunning)?{// ?Tenga en cuenta que si el hilo no es válido, el método de ejecución finalizará naturalmente y el hilo será inútil. ?
¿sincronizado?(taskQueue)?{?
mientras?(isRunning?amp ;amp;?taskQueue.isEmpty())?{//?¿La cola está vacía?
¿intentar?{?
taskQueue.wait(20);?
}?catch?(InterruptedException?e)?{?
e.printStackTrace();?
}?
}?
if?(!taskQueue.isEmpty())?
r?=?taskQueue.remove(0); //¿Eliminar tarea?
}?
if?(r?!=?null)?{?
r.run();//?¿Ejecutar tarea?
}?
tarea_terminada;?
r?=?null;?
}?
}
//?Dejar de funcionar y dejar que el hilo termine de ejecutar el método de ejecución y finalice naturalmente?
public ?void?stopWorker()?{?
isRunning?=?false;?
}?
}?
}