Así como las personas nacen, envejecen, enferman y mueren, los hilos también tienen que pasar por cuatro estados diferentes: iniciar (esperar), ejecutar, colgar y detenerse. Estos cuatro estados se pueden controlar mediante métodos de la clase Thread. Los métodos relacionados con estos cuatro estados en la clase Thread se detallan a continuación.
// 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 pública vacía () lanza InterruptedException;
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 hilo está en estado de espera, puede establecer varios atributos del hilo a través de los métodos de la clase Thread, como la prioridad del hilo (setPriority), el nombre del hilo (setName) y el tipo de hilo (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.
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 subproceso thread1 antes de continuar con la ejecución
System.out.println ("¡el hilo 1 ha finalizado!");
System.out.println("isAlive: " + hilo1.isAlive());
}
}
El resultado de ejecutar el código anterior:
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, existen dos métodos que se pueden utilizar para detener temporalmente la ejecución del hilo. Estos dos métodos son suspender y suspender. Después de usar suspender para suspender el hilo, puede activar el hilo 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.
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();
}
}
}
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. Cuando utilice el método de suspensión, debe utilizar throws o try{…}catch{…}. Debido a que el método de ejecución no puede utilizar throws, solo puede utilizar try{…}catch{…}. arrojará una InterruptedException al interrumpir un hilo usando el método de interrupción (este método se discutirá en 2.3.3). El método de sueño se define de la siguiente manera:
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 a 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, los subprocesos se utilizan en programas de servidor para monitorear las solicitudes de los clientes u otras tareas que requieren procesamiento cíclico. En este caso, estas tareas generalmente se colocan en un bucle, como un bucle while. Si desea que el bucle se ejecute para siempre, puede utilizar while(true){...} para manejarlo. Pero si desea que el bucle while salga bajo una determinada condición, 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.
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ó!");
}
}
2. Utilice el método de parada 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:
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.
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!");
}
}
sueño interrumpido
¡El hilo ha salido!
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()).