Escenarios empresariales de subprocesos múltiples
Multihilo utilizado en el desarrollo empresarial real:
1. Al iniciar sesión con el código de verificación de SMS, generalmente se abre un hilo separado para llamar a la interfaz de SMS y el hilo principal regresa.
2. El método de solicitud de envío ajax que se utiliza con frecuencia en el front-end es asíncrono porque es multiproceso.
3. Negocio de carga de imágenes.
4. En el servicio de archivos , los archivos cargados por cada nodo se clasifican. Hay muchas etapas, muchos nodos y la velocidad es muy lenta. Se necesitan 700 ms para 100 o 200 archivos. Después de usar el procesamiento de subprocesos múltiples, se pueden resolver decenas de milisegundos. Eficiencia Ha mejorado diez veces y es bueno. Los usuarios ya no pueden experimentar la sensación de retraso.
Subprocesamiento múltiple del propio marco
1. Tomcat responde a las solicitudes de una manera multiproceso Cientos de clientes acceden a Tomcat y una solicitud es recibida por un hilo.
2. El grupo de conexiones de druidas se utiliza a menudo cuando el proyecto se conecta a la base de datos.
Problemas de seguridad de varios subprocesos
Para ser claros, no habrá problemas de seguridad de subprocesos sin operar variables compartidas.
Hay problemas de seguridad de subprocesos, cuándo bloquear
Los datos compartidos pueden ser operados por dos subprocesos al mismo tiempo y luego bloqueados.
No pienses en la seguridad de los subprocesos cuando se trata de subprocesos múltiples. Entonces quiero bloquear. ¿Qué consecuencias causará el bloqueo? La eficiencia se reduce. Si utiliza varios subprocesos, la razón principal es mejorar la eficiencia. Luego, coloca un candado en cada subproceso. . Con todo, las consecuencias de usar candados indiscriminadamente son pequeñas cosas, o incluso estancadas.
La eficiencia y la seguridad de los datos es un subibaja, A es alto, B es bajo y el uso correcto de las cerraduras es la solución correcta.
Problemas comunes de subprocesos múltiples: ejecución y transferencia de parámetros de subprocesos múltiples
El problema de la coordinación de múltiples subprocesos, el multiproceso en sí no tiene orden de ejecución.
A veces se encontrará con un escenario así. Quiero mejorar la eficiencia y usar subprocesos múltiples, pero la transferencia de parámetros entre el método y el método es complicada. Muchos subprocesos se ejecutan a la vez, y el segundo subproceso necesita el primer subproceso. El resultado, cómo hacerlo.
Método join (): después de que finaliza el hilo que llamó al método join (), se pueden ejecutar otros hilos.
La imagen de arriba es la siguiente:
Tome otro ejemplo:
Resumen:
Si tiene dos subprocesos A, el subproceso B y el subproceso B y desea utilizar el resultado del subproceso A, se puede decir que es un problema de transferencia de parámetros del subproceso. ¿Cómo resolverlo?
Puede usar el método join (), pero su velocidad de ejecución definitivamente se ralentizará. ¿Qué debo hacer?
Puede tomar un truco y marcar la diferencia de tiempo . Según su propio negocio, no necesariamente tiene que hacer que el usuario ejecute subprocesos múltiples y termine el trabajo antes de tiempo.
El usuario no puede sentir el tiempo de decenas de milisegundos, pero si varios subprocesos se ejecutan juntos dentro de estos 100ms, debe utilizar los resultados de otros subprocesos. Definitivamente habrá un problema. ¿Cuántos milisegundos puede sentir la computadora? .
El método de operación multiproceso más simple
- Heredar la clase Thread
- Implementar la interfaz Runnable, sin valor de retorno, no puede lanzar una excepción.
- Implementa la interfaz invocable, tiene un valor de retorno y puede generar excepciones.
- Grupo de hilos.
El primero:
public class MyThread extends Thread {
public void run() {
System.out.println("我的新线程！");
}
}
También se puede usar directamente así, clase interna anónima.
El segundo tipo:
public class Test implements Runnable {
@Override
public void run() {
System.out.println("我的新线程！");
}
}
El tercer tipo: el
cuarto tipo:
presta atención
Los métodos start () y run () de la clase Thread se utilizan de forma diferente
Llamar al método start () es equivalente a iniciar un nuevo hilo.
El método run () se llama en el hilo original y no se inicia ningún hilo nuevo.
Introducción a los grupos de subprocesos
Cuando se utiliza la programación de subprocesos múltiples, la cantidad de subprocesos no es la mejor, y siempre se abren nuevos subprocesos, lo que consume una gran cantidad de recursos. Solo puede consumir el 10% de los recursos consumidos al procesar una pieza de lógica, mientras que los nuevos subprocesos destruyen subprocesos. El ciclo de vida ocupa el 90% de los recursos.
Así que es mejor reciclar el hilo. No es que puedas morir si tu hilo ejecuta esta tarea. No, puedes seguir ganando Ferrari para tu jefe.
Los hilos se reutilizan, pero no puedes dejar que los hilos te engañen. ¿Qué hacer si remas todos los días? Solo come y no. A los líderes no les gustan los hilos como este, por lo que el grupo de hilos debe controlarte y no permitirte pelear con perros. Ve a perseguir al pollo.
Ciclo de vida del hilo
Un hilo tiene un ciclo de vida y el grupo de hilos tiene un estado.
El hilo tiene cinco etapas y el grupo de hilos tiene cinco estados.
1. Nuevo
2. Listo
3. Ejecutar
4. Bloqueo
5. Terminación
Estado del grupo de subprocesos
EN EJECUCIÓN: acepta nuevas tareas y procesa las tareas en cola
APAGADO: no acepta nuevas tareas, pero procesa tareas en cola
DETENER: no acepte nuevas tareas, no procese tareas en cola e interrumpa las tareas en curso
ORDENAR: Se han terminado todas las tareas.
TERMINADO: Completado.
El método de operación de grupo de subprocesos más simple
ThreadPoolExecutor clase:
························ Claves de teclas ··················· ······
int corePoolSize
La cantidad de subprocesos principales, cuántos subprocesos planea necesitar para este grupo de subprocesos en función de las necesidades comerciales. Una vez creado el grupo de subprocesos, el número de subprocesos en el grupo es 0 y se realiza una solicitud para iniciar un subproceso.
int maximumPoolSize
Este parámetro determina el número máximo de subprocesos que puede crear el grupo de subprocesos.
mucho tiempo keepAliveTime
El tiempo máximo de inactividad de un hilo. Este parámetro no es válido para el hilo principal. El hilo principal es más poderoso y nadie puede controlarlo. El tiempo de inactividad solo tendrá efecto cuando el hilo actual> hilo principal, y si el tiempo de inactividad de un hilo alcanza este punto, se terminará.
Unidad de tiempo Unidad
时间 单位。
TimeUnit.DAYS.
TimeUnit.HOURS.
TimeUnit.MINUTES.
TimeUnit.SECONDS.
TimeUnit.MILLISECONDS.
TimeUnit.MICROSECONDS.
TimeUnit.NANOSECONDS.
BlockingQueue workQueue
La cola de hebras en espera almacena las tareas en espera de ser ejecutadas.
ArrayBlockingQueue: basado en una matriz, el tamaño se especifica cuando se crea y las tareas en cola son limitadas.
LinkedBlockingQueue: según una lista vinculada, una cola ilimitada, después de que el hilo principal está lleno, todas las tareas entrantes ingresan a la cola hasta que se agotan los recursos.
SynchronousQueue: No es un equipo, solo crea un nuevo hilo y realiza tareas.
ThreadFactory threadFactory
Fábrica de creación de hilos.
Controlador RejectedExecutionHandler
Estrategia de rechazo, si el hilo actual ha alcanzado el número máximo de hilos, se ejecutará la estrategia de rechazo.
ThreadPoolExecutor.AbortPolicy: lanza una excepción.
ThreadPoolExecutor.DiscardPolicy: Descarta tareas sin lanzar excepciones.
ThreadPoolExecutor.DiscardOldestPolicy: descarte la primera tarea en la cola y luego ejecute la tarea nuevamente.
ThreadPoolExecutor.CallerRunsPolicy: tareas de procesamiento de subprocesos de llamadas
Proceso general
El parámetro anterior es para que usted mismo diseñe un grupo de subprocesos Un punto muy importante es el número de subprocesos.
Current <core, crea un nuevo hilo para procesar la solicitud.
El núcleo <actual> es el más grande y entra en la cola de espera para su ejecución.
Core = Max, crea un grupo de subprocesos de tamaño fijo.
El número máximo de subprocesos es infinito y el grupo de subprocesos es ilimitado para abrir nuevos subprocesos.
El proceso general es:
Paso 1: Reciba la solicitud y determine el tamaño del número actual de subprocesos y el número de subprocesos centrales:
·············· Si es menor que el número de subprocesos centrales, se abrirá un nuevo subproceso para realizar la tarea.
············· Si es mayor que el número de hilos centrales, ingrese a la cola de espera.
Paso 2: Espere la cola y determine si está llena. Este paso es muy importante, no solo para determinar si la cola está llena, sino también para ver la estrategia de cola establecida.
············ Si no está lleno, puede entrar y esperar la ejecución.
············· Si está lleno y falla la entrada, se realizarán diferentes operaciones según la estrategia de cola correspondiente.
Paso 3: Determine el tamaño del número actual de hilos y el número máximo de hilos
············· Si es mayor que el número máximo de hilos, ejecute la estrategia de rechazo.
············ Si el número de hilos es menor que el número máximo de hilos, la tarea se enviará para su ejecución.
Si desea evitar problemas, puede utilizar directamente el JDK proporcionado. Comprenda el significado de estos siete parámetros, los siguientes cuatro estarán bien.
1 、 newFixedThreadPool
2 、 newCachedThreadPool
3 、 newSingleThreadExecutor
4 、 newSingleThreadScheduledExecutor
Método de cierre del grupo de subprocesos
1. Apagar: Apagar de manera ordenada Después de que se ejecuta el método, no se recibirán nuevas tareas y todas las tareas en la cola se apagarán después de la ejecución.
2. shutdownNow: cierre a la fuerza todas las tareas no ejecutadas y en ejecución, cierre instantáneamente y vuelva a las tareas no ejecutadas.
················································ ···························
¿Ha abandonado la escuela?