prefacio
Escribir a mano un grupo de subprocesos Java simple: ¿enfocarse en cómo garantizar que siempre haya subprocesos en ejecución? ¿Cómo asegurarse de que el subproceso consuma la información de la tarea enviada? . El subproceso subyacente que se ha mantenido en ejecución es un bucle infinito. Utilice colas de mensajes para garantizar el envío y el consumo de información. Las colas de mensajes utilizan el principio de primero en entrar, primero en salir.
paso
El punto central del grupo de subprocesos: mecanismo de multiplexación
- 1. Cree un hilo fijo de antemano y siga ejecutándose ---- implementación de bucle infinito
- 2. Las tareas de subprocesos enviadas se almacenan en caché en un conjunto de colas concurrentes y se entregan a nuestros subprocesos en ejecución para su ejecución.
- 3. El subproceso en ejecución obtiene la ejecución de la tarea de la cola
1. Crea un hilo fijo
De acuerdo con los parámetros pasados, determine cuántos subprocesos ejecutar todo el tiempo. Por ejemplo, si el parámetro pasado es 2, se crearán dos subprocesos que siempre se están ejecutando. Los subprocesos siempre en ejecución se implementan mediante un bucle infinito.
public class MyTestExecutors {
private List<WorkThread> workThread;
/**
* 最大线程数
* @param maxThreadCount
*/
public MyTestExecutors(int maxThreadCount){
//提前创建好固定的线程一直在运行状态---死循环实现
workThread = new ArrayList<WorkThread>(maxThreadCount);
for (int i = 0; i < maxThreadCount; i++) {
new WorkThread().start();
}
}
class WorkThread extends Thread{
@Override
public void run() {
while (true){
}
}
}
}
2. Envíe la tarea a la cola de mensajes.
Las tareas de subprocesos enviadas se almacenan en caché en una colección de colas simultáneas y se entregan a nuestros subprocesos en ejecución para su ejecución.
Sugerencia: el método de oferta () es un método que se usa a menudo en las colas de Java y su función es agregar un elemento al final de la cola. Específicamente, el método offer() insertará el elemento especificado al final de esta cola y devolverá falso si la cola está llena . De lo contrario, devuelve verdadero, lo que indica que el elemento se agregó correctamente.
/**
* 线程任务缓存到一个并发队列集合
* @param command
* @return
*/
public boolean execute(Runnable command){
return runnableDeque.offer(command);
}
public class MyTestExecutors {
private List<WorkThread> workThread; //工作线程
private BlockingDeque<Runnable> runnableDeque; //队列
/**
* @param maxThreadCount 最大线程数
* @param dequeSize 缓存消息队列
*/
public MyTestExecutors(int maxThreadCount,int dequeSize){
//1、限制队列容量缓存
runnableDeque = new LinkedBlockingDeque<Runnable>(dequeSize);
//2、提前创建好固定的线程一直在运行状态---死循环实现
workThread = new ArrayList<WorkThread>(maxThreadCount);
for (int i = 0; i < maxThreadCount; i++) {
new WorkThread().start();
}
}
class WorkThread extends Thread{
@Override
public void run() {
while (true){
}
}
}
/**
* 线程任务缓存到一个并发队列集合
* @param command
* @return
*/
public boolean execute(Runnable command){
return runnableDeque.offer(command);
}
public static void main(String[] args) {
MyTestExecutors testExecutors = new MyTestExecutors(2, 2);
for (int i = 0; i < 10; i++) {
final int finalI = i;
testExecutors.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+","+finalI);
}
});
}
}
}
3. Cola de mensajes de consumo de subprocesos
El subproceso en ejecución obtiene la ejecución de la tarea de la cola
class WorkThread extends Thread{
@Override
public void run() {
while (true){
Runnable runnable = runnableDeque.poll();
if(runnable != null){
runnable.run();
}
}
}
}
4. prueba
En el caso de 2, los dos subprocesos fijos aún no han ejecutado tareas y solo dos tareas de subprocesos se almacenan en caché en la cola.
En el caso de 4, se corrige que dos subprocesos ejecutan tareas y dos tareas de subprocesos se almacenan en caché en la cola.
5. Detener hilo [código completo]
Cómo detener dos subprocesos existentes después de completar la ejecución de la tarea del subproceso. Es necesario cambiar la condición del bucle infinito dando un bit de bandera. Una vez que finaliza la tarea, establezca el bit de indicador en falso y, al mismo tiempo, debe juzgar si se completó la ejecución de las tareas en la cola. El subproceso se detiene solo después de que se completan todas las tareas almacenadas en caché en la cola.
while (isRun || runnableDeque.size()>0)
package com.grg.demo.testDemo02;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;
/**
* @author zyz
* @version 1.0
* @data 2023/7/11 23:01
* @Description: 手写线程池
* 线程池核心点 ：复用机制 -----
* 1、提前创建好固定的线程一直在运行状态----死循环实现
* 2、提交的线程任务缓存到一个并发队列集合中，交给我们正在运行的线程执行
* 3、正在运行的线程就从队列中获取该任务执行
*/
public class MyTestExecutors {
private List<WorkThread> workThread; //工作线程
private BlockingDeque<Runnable> runnableDeque; //队列
private Boolean isRun = true;
/**
*
* @param maxThreadCount 最大线程数
* @param dequeSize 缓存消息队列
*/
public MyTestExecutors(int maxThreadCount,int dequeSize){
//2、限制队列容量缓存
runnableDeque = new LinkedBlockingDeque<Runnable>(dequeSize);
//1、提前创建好固定的线程一直在运行状态---死循环实现
workThread = new ArrayList<WorkThread>(maxThreadCount);
for (int i = 0; i < maxThreadCount; i++) {
new WorkThread().start();
}
}
class WorkThread extends Thread{
@Override
public void run() {
while (isRun || runnableDeque.size()>0){
Runnable runnable = runnableDeque.poll();
if(runnable != null){
runnable.run();
}
}
}
}
/**
* 线程任务缓存到一个并发队列集合
* @param command
* @return
*/
public boolean execute(Runnable command){
return runnableDeque.offer(command);
}
public static void main(String[] args) {
MyTestExecutors testExecutors = new MyTestExecutors(2, 2);
for (int i = 0; i < 10; i++) {
final int finalI = i+1;
testExecutors.execute(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+","+finalI);
}
});
}
testExecutors.isRun = false;
}
}
