Copie el código de código de la siguiente manera:
// Iniciar hilo
inicio público vacío ();
ejecución pública vacía ();
// Suspender y reactivar hilos
currículum vacío público (); // No recomendado para su uso
suspensión pública vacía (); // No recomendado para su uso
sueño vacío estático público (millis largos);
sueño vacío estático público (millis largos, int nanos);
//terminar hilo
parada pública vacía (); // No recomendado para su uso
interrupción pública vacía ();
//Obtener el estado del hilo
público booleano está vivo ();
el booleano público está interrumpido ();
booleano estático público interrumpido ();
// método de unión
unión nula pública () lanza InterruptedException;
1. Crear y ejecutar hilos
El hilo no ejecuta el código en el método de ejecución inmediatamente después de su establecimiento, sino que está en estado de espera. Cuando el subproceso está en estado de espera, puede establecer varios atributos del subproceso a través de los métodos de la clase Thread, como la prioridad del subproceso (setPriority), el nombre del subproceso (setName) y el tipo de subproceso (setDaemon).
Cuando se llama al método de inicio, el hilo comienza a ejecutar el código en el método de ejecución. El hilo entra en estado de ejecución. Puede utilizar el método isAlive de la clase Thread para determinar si el hilo se está ejecutando. Cuando el hilo está en estado de ejecución, isAlive devuelve verdadero. Cuando isAlive devuelve falso, el hilo puede estar en estado de espera o detenido. El siguiente código demuestra el cambio entre los tres estados de creación, ejecución y detención del subproceso, y genera el valor de retorno isAlive correspondiente.
Copie el código de código de la siguiente manera:
paquete capítulo2;
LifeCycle de clase pública extiende Thread
{
ejecución pública vacía()
{
int norte = 0;
mientras ((++n) < 1000);
}
public static void main (String[] args) lanza una excepción
{
Hilo de ciclo de vida1 = nuevo ciclo de vida();
System.out.println("isAlive: " + hilo1.isAlive());
hilo1.start();
System.out.println("isAlive: " + hilo1.isAlive());
thread1.join(); // Espere a que finalice el hilo thread1 antes de continuar con la ejecución
System.out.println ("¡el hilo 1 ha finalizado!");
System.out.println("isAlive: " + hilo1.isAlive());
}
}
Tenga en cuenta que el método de unión se utiliza en el código anterior. La función principal de este método es garantizar que el programa continúe ejecutándose después de que se complete el método de ejecución del hilo. Este método se presentará en un artículo posterior.
El resultado de ejecutar el código anterior:
está vivo: falso
está vivo: verdadero
¡El hilo 1 ha terminado!
está vivo: falso
2. Suspender y reactivar hilos
Una vez que el hilo comienza a ejecutar el método de ejecución, no saldrá hasta que se complete el método de ejecución. Sin embargo, durante la ejecución del hilo, puede detener temporalmente la ejecución del hilo mediante dos métodos. Estos dos métodos son suspender y dormir. Después de usar suspender para suspender un hilo, puede reactivarlo mediante el método de reanudación. Después de usar la suspensión para hacer que el subproceso duerma, el subproceso solo puede estar en el estado listo después del tiempo establecido (después de que finaliza la suspensión del subproceso, es posible que el subproceso no se ejecute inmediatamente, solo ingresa al estado listo, esperando que el sistema lo programe) .
Aunque suspender y reanudar pueden suspender y reactivar subprocesos fácilmente, el uso de estos dos métodos puede provocar que sucedan cosas impredecibles. Por lo tanto, estos dos métodos están marcados como obsoletos (protesta), lo que indica que estos dos métodos pueden eliminarse en el futuro jdk. versiones, así que trate de no utilizar estos dos métodos para operar subprocesos. El siguiente código demuestra el uso de los métodos de suspensión, suspensión y reanudación.
Copie el código de código de la siguiente manera:
paquete capítulo2;
clase pública MyThread extiende Thread
{
clase SleepThread extiende Thread
{
ejecución pública vacía()
{
intentar
{
dormir(2000);
}
captura (Excepción e)
{
}
}
}
ejecución pública vacía()
{
mientras (verdadero)
System.out.println(new java.util.Date().getTime());
}
public static void main (String[] args) lanza una excepción
{
Hilo MiHilo = nuevo MiHilo();
SleepThread sleepThread = thread.new SleepThread();
sleepThread.start(); // Iniciar la ejecución del hilo sleepThread
sleepThread.join(); // Retrasa el hilo sleepThread durante 2 segundos
hilo.start();
bandera booleana = falso;
mientras (verdadero)
{
sleep(5000); // Retrasa el hilo principal durante 5 segundos
bandera = !bandera;
si (bandera)
hilo.suspender();
demás
hilo.resume();
}
}
}
En la superficie, los efectos de dormir y suspender son similares, pero el método de dormir no es equivalente a suspender. La mayor diferencia entre ellos es que puede usar el método suspender en un hilo para suspender otro hilo. Por ejemplo, en el código anterior, el hilo está suspendido en el hilo principal. La suspensión solo funciona en el hilo que se está ejecutando actualmente. En el código anterior, sleepThread y el hilo principal duermen durante 2 segundos y 5 segundos respectivamente. Cuando utilice la suspensión, tenga en cuenta que no puede suspender un hilo en otro hilo. Por ejemplo, usar el método thread.sleep (2000) en el método principal no puede hacer que el hilo duerma durante 2 segundos, pero solo puede hacer que el hilo principal duerma durante 2 segundos.
Hay dos puntos a tener en cuenta al utilizar el método del sueño:
1. El método de suspensión tiene dos formas sobrecargadas. Una de las formas sobrecargadas no solo puede establecer milisegundos, sino también nanosegundos (1.000.000 de nanosegundos equivalen a 1 milisegundo). Sin embargo, la máquina virtual Java en la mayoría de las plataformas de sistemas operativos no tiene una precisión de nanosegundos. Por lo tanto, si se configuran los nanosegundos para la suspensión, la máquina virtual Java tomará el milisegundo más cercano a este valor.
2. Se deben utilizar throws o try{...}catch{...} cuando se utiliza el método de suspensión. Debido a que el método de ejecución no puede usar throws, solo puede usar try{...}catch{...}. Cuando el subproceso está inactivo y se utiliza el método de interrupción (este método se analizará en 2.3.3) para interrumpir el subproceso, el modo de suspensión generará una InterruptedException. El método de sueño se define de la siguiente manera:
Copie el código de código de la siguiente manera:
El sueño vacío estático público (millis largos) arroja una excepción interrumpida
el sueño vacío estático público (millis largos, int nanos) arroja una excepción interrumpida
3. Tres formas de terminar un hilo
Hay tres formas de terminar un hilo.
1. Utilice el indicador de salida para que el hilo salga normalmente, es decir, el hilo termina cuando se completa el método de ejecución.
2. Utilice el método de detención para finalizar el hilo por la fuerza (este método no se recomienda porque detener, al igual que suspender y reanudar, también puede producir resultados impredecibles).
3. Utilice el método de interrupción para interrumpir el hilo.
1. Termine el hilo usando la bandera de salida.
Cuando se ejecuta el método de ejecución, el hilo saldrá. Pero a veces el método de ejecución nunca termina. Por ejemplo, utilice subprocesos en programas de servidor para monitorear las solicitudes de los clientes u otras tareas que requieran procesamiento cíclico. En este caso, estas tareas generalmente se colocan en un bucle, como un bucle while. Si desea que el ciclo se ejecute para siempre, puede usar while(true){...} para manejarlo. Pero si desea que el bucle while salga bajo ciertas condiciones, la forma más directa es establecer un indicador de tipo booleano y establecer este indicador en verdadero o falso para controlar si el bucle while sale. A continuación se proporciona un ejemplo de cómo terminar un hilo usando el indicador de salida.
Copie el código de código de la siguiente manera:
paquete capítulo2;
la clase pública ThreadFlag extiende Thread
{
salida booleana volátil pública = falso;
ejecución pública vacía()
{
mientras (!salir);
}
public static void main (String[] args) lanza una excepción
{
Hilo ThreadFlag = nuevo ThreadFlag();
hilo.start();
sleep(5000); // El hilo principal se retrasa durante 5 segundos
thread.exit = true; // Terminar el hilo
hilo.join();
System.out.println("¡El hilo salió!");
}
}
Un indicador de salida, salida, se define en el código anterior. Cuando la salida es verdadera, el bucle while sale y el valor predeterminado de salida es falso. Al definir la salida, se utiliza una palabra clave Java volátil. El propósito de esta palabra clave es sincronizar la salida, lo que significa que solo un hilo puede modificar el valor de salida al mismo tiempo.
2. Utilice el método de detención para terminar el hilo.
Utilice el método de detención para finalizar por la fuerza un subproceso en ejecución o suspendido. Podemos usar el siguiente código para terminar el hilo:
hilo.stop();
Aunque el uso del código anterior puede terminar el hilo, usar el método de detención es muy peligroso. Al igual que apagar repentinamente la computadora en lugar de apagarla de acuerdo con el procedimiento normal, puede producir resultados impredecibles. Por lo tanto, no se recomienda su uso. el método de parada.
3. Utilice el método de interrupción para terminar el hilo.
El uso del método de interrupción para terminar un hilo se puede dividir en dos situaciones:
(1) El hilo está en un estado bloqueado, como cuando se usa el método de suspensión.
(2) Utilice while(!isInterrupted()){...} para determinar si el hilo está interrumpido.
En el primer caso, al utilizar el método de interrupción, el método de suspensión generará una excepción InterruptedException, mientras que en el segundo caso el hilo saldrá directamente. El siguiente código demuestra el uso del método de interrupción en el primer caso.
Copie el código de código de la siguiente manera:
paquete capítulo2;
la clase pública ThreadInterrupt extiende Thread
{
ejecución pública vacía()
{
intentar
{
dormir(50000); // retraso 50 segundos
}
captura (Excepción interrumpida e)
{
System.out.println(e.getMessage());
}
}
public static void main (String[] args) lanza una excepción
{
Hilo hilo = new ThreadInterrupt();
hilo.start();
System.out.println("¡Presione cualquier tecla dentro de 50 segundos para interrumpir el hilo!");
Sistema.en.read();
hilo.interrupt();
hilo.join();
System.out.println("¡El hilo ha cerrado!");
}
}
Los resultados de ejecutar el código anterior son los siguientes:
Copie el código de código de la siguiente manera:
¡Presione cualquier tecla dentro de los 50 segundos para interrumpir el hilo!
sueño interrumpido
¡El hilo ha salido!
Después de llamar al método de interrupción, el método de suspensión genera una excepción y luego genera el mensaje de error: suspensión interrumpida.
Nota: Hay dos métodos en la clase Thread para determinar si el hilo finaliza mediante el método de interrupción. Uno es el método estático interrumpido () y el otro es el método no estático isInterrupted (). La diferencia entre estos dos métodos es que interrumpido se usa para determinar si el hilo actual está interrumpido, mientras que isInterrupted se puede usar para determinar si. otros hilos se interrumpen. Por lo tanto, while (!isInterrupted()) también se puede reemplazar por while (!Thread.interrupted()).