Hilos de creación de Java (clase de interfaz runnable y hilo)
En la mayoría de los casos, se crea un hilo instanciando un objeto de hilo. Java define dos maneras:
Lo siguiente describe cada método a su vez.
Implementación de la interfaz ejecutable
La forma más fácil de crear un hilo es crear una clase que implementa la interfaz ejecutable. Runnable Abstracts una unidad de ejecución de código. Puede crear hilos para cada objeto implementando la interfaz Runnable. Para implementar la interfaz Runnable, una clase solo necesita implementar un método simple de ejecución (), que se declara de la siguiente manera:
Public void run ()
En Run (), puede definir el código para crear nuevos hilos. Es crucial comprender lo siguiente: el método Run () puede llamar a otros métodos, consultar otras clases y declarar variables como el hilo principal. La única diferencia es que Run () establece otra entrada de ejecución de hilos concurrentes en el programa. Cuando Run () regresa, el hilo termina.
Después de haber creado una clase que implementa la interfaz ejecutable, debe instanciar un objeto de la clase de subprocesos dentro de la clase. La clase de hilo define varios constructores. Lo que usaremos es el siguiente:
Thread (Runnable Threadob, String ThreadName)
En este constructor, ThreadOB es una instancia que implementa la clase de interfaz ejecutable. Esto define el punto de partida para la ejecución de hilos. El nombre del nuevo hilo se define por ThreadName.
Después de que se crea un nuevo hilo, no se ejecuta hasta que se llame a su método Start (), que se define en la clase de subproceso. Esencialmente, Start () ejecuta una llamada para ejecutar (). El método Start () se declara de la siguiente manera:
inicio vacío ()
El siguiente ejemplo es crear un nuevo hilo y comenzarlo en ejecución:
// Crear un segundo hilo. Clase NewThread implementos Runnable {Thread t; : " + t); t.start (); // iniciar el hilo} // Este es el punto de entrada para el segundo hilo. public void run () {try {for (int i = 5; i> 0; i - -) {System.out.println ("Hilo infantil:" + i); out .println ("Hilo infantil de salida"); 0; ); En el constructor NewThread, el nuevo objeto de subproceso se crea mediante la siguiente declaración:
t = nuevo hilo (este, "hilo de demostración");
Esto indica que en este objeto desea que el nuevo hilo llame al método run (). Luego, se llama a Start () y la ejecución del hilo se inicia con el método run (). Esto hace que el hilo infantil para el bucle inicie la ejecución. Después de llamar a Start (), el constructor NewThread regresa a Main (). Cuando se restaura el hilo principal, alcanza el bucle for. Los dos hilos continúan funcionando, compartiendo la CPU hasta que termina su bucle. La salida de este programa es la siguiente:
Hilo infantil: hilo [hilo de demostración, 5, principal] hilo principal: 5child hilo: 5child hilo: 4main hilo: 4 hilo de colmillo: 3cild hilo: 2 hilo de mina: 3cild hilo: 1e hilo infantil xiting. Hilo principal: 2Main hilo: 1 hilo de mina Salir .
Como se mencionó anteriormente, en un programa de múltiples subprocesos, el hilo principal generalmente debe ser el último hilo que termina en ejecución. De hecho, para algunos JVMs antiguos, si el hilo principal termina antes del hilo infantil, el sistema de tiempo de ejecución de Java puede "colgar". El programa mencionado anteriormente asegura que el hilo principal termine al final, porque el hilo principal duerme durante 1000 milisegundos, mientras que el hilo infantil es de solo 500 milisegundos. Esto hace que el hilo del niño termine antes de que termine el hilo principal. En resumen, verá una mejor manera de esperar a que termine el hilo.
Hilo extendido
Otra forma de crear un hilo es crear una nueva clase que extienda la clase de hilo y luego cree una instancia de esa clase. Cuando una clase hereda el hilo, debe sobrecargar el método run (), que es la entrada al nuevo hilo. También tiene que llamar al método Start () para iniciar la nueva ejecución del hilo. Lo siguiente es reescribir el programa anterior con la clase de hilo extendido:
// Crear un segundo hilo extendiendo ThreadClass NewThread extiende el hilo {NewThread () {// Crear un nuevo hilo super ("Demo Thread"); (); / Inicie el hilo} // Este es el punto de entrada para el segundo hilo. ("Hilo infantil:" + I); ");}} clase ExtendThread {public static void main (string args []) {new NewThread (); // Cree un nuevo hilo try {for (int i = 5; i> 0; i--) {System. Out :::::::::::::::. Hilo principal interrumpido. ");} System.ou T.println (" Hilo principal que sale ");}} Este programa genera la misma salida que la versión anterior. El hilo infantil es generado por el objeto NewThread instanciado, que se deriva de la clase de hilo. Tenga en cuenta la llamada a Super () en NewThread. Este método llama al constructor de subprocesos de la siguiente forma:
Public Thread (String ThreadName)
Aquí, ThreadName especifica el nombre del hilo.
Elija el método correcto
En este punto, definitivamente se preguntará por qué Java tiene dos formas de crear hilos infantiles, cuál es mejor. Todas las preguntas se atribuyen a un punto. La clase de subprocesos define una variedad de métodos que pueden sobrecargarse por clases derivadas. Para todos los métodos, lo único que debe sobrecargarse es el método run (). Por supuesto, este es el mismo método requerido para implementar la interfaz ejecutable. Muchos programadores de Java creen que las clases deben extenderse solo cuando se fortalecen o modifican. Por lo tanto, si no sobrecarga otros métodos de hilo, es mejor implementar solo la interfaz ejecutable. Por supuesto que depende de ti decidir. Sin embargo, en otras partes de este capítulo, aplicamos clases que implementan la interfaz ejecutable para crear subprocesos.