[Multithreading] -Analiza los elementos básicos necesarios para crear un hilo desde el constructor de la clase Thread

Uno, el constructor de la clase Thread

En el desarrollo real, ¿qué debemos hacer si queremos iniciar una nueva tarea de hilo? Así es, llama al método start () de la clase Thread para iniciar una nueva tarea de hilo. Entonces, ¿cuáles son las condiciones necesarias para que un objeto Thread sea los elementos básicos para que comience un nuevo hilo? Podemos iniciar el análisis en el constructor de la clase Thread.

Thread t1 =new Thread();

Entonces, ¿qué hace un constructor de parámetros vacío por nosotros? Hacemos clic en el constructor para ver el siguiente código:

	public Thread() {
    
    
		init(null, null, "Thread-" + nextThreadNum(), 0L);
	}

La clase Thread llama a un método llamado init en un constructor con parámetros vacíos, continuamos ingresando el método init y miramos hacia abajo:

	private void init(ThreadGroup paramThreadGroup, Runnable paramRunnable, String paramString, long paramLong) {
    
    
		init(paramThreadGroup, paramRunnable, paramString, paramLong, null, true);
	}

En el método init, llama a su propio método sobrecargado init. Hoy, necesitamos analizar los elementos más básicos para crear un hilo a partir de los parámetros de este método sobrecargado. Por supuesto, todavía nos enfocamos en analizar los parámetros mencionados en el constructor proporcionado por la clase Thread, lo que nos facilita entender qué parámetros son los más importantes cuando se genera la clase Thread. Primero, abrimos la documentación del JDK, buscamos la clase Thread y luego verificamos qué métodos de construcción nos proporciona el JDK:

1. Tarea de subproceso (ejecutable)

En primer lugar, aquí es donde luché durante mucho tiempo. Como se menciona en la documentación de JDK, las dos formas de crear subprocesos son heredar la clase de subproceso o implementar la interfaz ejecutable. Cuando realmente queremos implementar negocios de subprocesos múltiples, debemos usar el método start () de la clase de subproceso para lograr , Y llamar directamente al método de ejecución del objeto ejecutable depende del negocio actual de procesamiento de subprocesos. Por ejemplo, el siguiente código:

package xiao.thread.constructor;

public class Demo01 implements Runnable{
    
    
	@Override
	public void run() {
    
    
		System.out.println("当前线程名是："+Thread.currentThread().getName());
	}
	public static void main(String[] args) {
    
    
		new Demo01().run();
	}
}

Creamos una instancia que implementa la interfaz ejecutable a través de new e imprimimos el nombre del hilo que está usando en este momento en el método de ejecución. Resulta que

la instancia no implementa un nuevo hilo, pero usa el hilo principal para continuar procesando el método de ejecución. La lógica en el cuerpo, y si queremos procesar la lógica en el método de ejecución a través de un nuevo hilo, necesitamos escribir:

package xiao.thread.constructor;

public class Demo01 implements Runnable{
    
    
	@Override
	public void run() {
    
    
		System.out.println("当前线程名是："+Thread.currentThread().getName());
	}

	public static void main(String[] args) {
    
    
		new Thread(new Demo01()).start();
	}
}

El resultado en este momento es:

en este momento, la unidad de negocio realmente está iniciando un nuevo hilo para manejar la lógica de la tarea que queremos. Entonces, ¿hay algún problema con los dos métodos de creación mencionados en la documentación de la API de JDK? De hecho, creo que esto debería ser un problema con la comprensión de esta oración. A través del código anterior, no es difícil ver que implementar la interfaz ejecutable no inicia un hilo para nosotros, pero proporciona una tarea que puede ser ejecutada por el hilo. Entonces podemos entender que la implementación de la interfaz ejecutable y la herencia de la clase Thread en realidad crean una tarea de subproceso para nosotros. Esta tarea en sí no se puede iniciar. Cuando queremos iniciar esta tarea, solo podemos confiar en la existente. El hilo puede ser. Para lograr esta tarea a través de un nuevo hilo, debe lograrlo a través del método local start en la clase Thread. Entonces, la clase Thread nos proporciona un parámetro en el constructor.

Usando esta construcción parametrizada, podemos iniciar un nuevo hilo para lograr la tarea del hilo que queremos completar. Por supuesto, también podemos usar directamente clases internas anónimas para crear una tarea de hilo:

	public static void main(String[] args) {
    
    
		new Thread(() -> {
    
    
			System.out.println("当前线程名是：" + Thread.currentThread().getName());
		}).start();;
	}

2. Nombre del hilo

En la especificación de programación emitida por Alibaba en 19 años, se estipula claramente que debemos darle un nombre significativo al hilo: la

razón también es muy clara, y es volver atrás cuando un problema vuelva a ocurrir. Por supuesto, esta es solo una especificación recomendada por Alibaba Cuando estamos construyendo una nueva ciudad de línea, ¿qué pasa si no especificamos el nombre del hilo? En el método init de la clase Thread, podemos ver el siguiente código:

		init(null, null, "Thread-" + nextThreadNum(), 0L);

Cuando no especificamos un nombre para el nuevo hilo, el hilo comenzará con Thread-, y luego empalmará el número obtenido por un nextThreadNum para registrar el nombre del hilo actual. Debido a la gran similitud de este nombre, sin duda aumentará nuestra carga de trabajo cuando haya problemas en línea. Por ejemplo: cuando

usamos el comando jstack para rastrear subprocesos, debido a estos nombres de subprocesos sin referencia, no podemos ubicar qué módulo tiene el problema en primer lugar. Por tanto, cuando creamos un hilo, es mejor poner la información comercial actual en el nombre del hilo para facilitar la trazabilidad.

3. Grupo de subprocesos (ThreadGroup)

Primero que nada, tenemos que mirar la definición de grupo de hilos:

El grupo de subprocesos (ThreadGroup) es una clase de gestión de subprocesos compuesta por subprocesos.
En Java, cada subproceso pertenece a un miembro de una gestión de grupo de subprocesos. Por ejemplo, un subproceso se genera en el flujo de trabajo principal de la función principal main (). El hilo pertenece a un miembro de la gestión del grupo de hilos principal.

El grupo de subprocesos es fácil de entender y se utiliza para administrar subprocesos. La relación entre los grupos de subprocesos es muy similar a la gestión familiar china. Todos tienen un subproceso y nunca pueden ser libres, y los subprocesos también pueden encontrar los grupos de subprocesos a los que pertenecen. El grupo de subprocesos no se usa mucho en el trabajo diario. Se usa principalmente para administrar un lote de subprocesos, como interrumpir / suspender / reanudar / detener, etc., aquí preste atención a la destrucción de ThreadGroup El método es borrar este subproceso group y todos sus grupos de subprocesos secundarios, pero tenga en cuenta que todos los grupos de subprocesos aquí, incluidos los grupos de subprocesos secundarios, deben estar vacíos, lo que significa que todos los subprocesos del grupo de subprocesos están muertos; de lo contrario, se lanzará una excepción.
Archivo adjunto: Cómo administrar grupos de hilos

1) La atribución automática, es decir, los hilos o grupos de hilos tienen un mecanismo predeterminado. En términos sencillos, para crear un hilo o grupo de hilos, debe tener su propio grupo de hilos, y cada hilo no puede ser libre. Esto se puede hacer viendo new Se conocerá el código fuente de Thread () y new ThreadGroup ().
2) El objeto principal puede crear el objeto secundario, y el objeto secundario aún puede crear el objeto secundario, porque el grupo de subprocesos se implementa en una estructura de árbol.

4. Tamaño de la pila (stackSize)

Como último constructor de Thread, stackSize se utiliza principalmente para especificar el tamaño del espacio de pila del hilo recién creado. Este tamaño también especifica el valor predeterminado en el código fuente:

Entonces, ¿por qué debería ser 0?
Este problema se explica claramente en el documento de la JVM, porque si el parámetro stackSize surte efecto depende de la plataforma en la que se ejecuta la jvm. Cuando la plataforma admite el parámetro stackSize para especificar el tamaño del espacio de la pila, la jvm utilizará el valor mínimo admitido por la plataforma Inicialice el tamaño del espacio de la pila. Entonces, un parámetro de 0 significa que se crea el tamaño mínimo de memoria de pila admitido por la plataforma.

Dos, resumen

A través del análisis del constructor de la clase Thread, sabemos principalmente que los siguientes cuatro elementos son principalmente necesarios al crear un hilo:

1. Tareas de subprocesos proporcionadas por ejecutable : aquí debemos prestar atención a lo que hemos mencionado en la documentación de la API de JDK
   
   cuando solo queremos lograr la separación o expansión comercial, es mejor no integrar Thread para lograrlo, a menos que espere mejorar o integrar la función de Thread; de lo contrario, debería usarse para implementar la interfaz ejecutable.
2. Nombre del hilo : establecer un nombre comercial para el hilo puede ahorrarnos mucho tiempo al solucionar problemas más adelante
3. Grupo de subprocesos : especificar un grupo de subprocesos específico es conveniente para nosotros para mantener subprocesos comerciales específicos rápidamente
4. Tamaño del hilo : crear un hilo de un tamaño específico también puede facilitarnos el cálculo de la utilización del espacio de memoria de la pila