1. El concepto de hilo: el hilo se refiere al flujo de ejecución de una tarea de principio a fin. El hilo proporciona un mecanismo para ejecutar tareas. Para Java, se pueden ejecutar múltiples hilos simultáneamente en un programa, y estos hilos pueden ejecutarse simultáneamente en un sistema multiprocesador. Cuando el programa se ejecuta como una aplicación, el intérprete Java inicia un hilo para el método main ().
2. Paralelo y concurrencia:
(1) Concurrencia: en un solo sistema de procesadores, varios subprocesos comparten el tiempo de CPU, y el sistema operativo es responsable de programarlos y asignarles recursos.
(2) Paralelismo: en un sistema multiprocesador, varios procesadores pueden ejecutar múltiples hilos al mismo tiempo. Estos hilos pueden ejecutarse simultáneamente al mismo tiempo. A diferencia de la concurrencia, solo varios hilos pueden compartir el tiempo de la CPU, y solo un hilo puede ejecutarse al mismo tiempo.
3. Creación de hilos:
(1) Concepto básico: cada tarea en Java es un objeto ejecutable. Para crear una tarea, la clase de tareas primero debe definirse, y la clase de tareas debe implementar la interfaz ejecutable. Y los hilos son esencialmente objetos que son convenientes para la ejecución de tareas. El proceso de ejecución de un hilo es la ejecución del método run () en una clase de tareas hasta el final.
(2) Crear hilos a través de la interfaz ejecutable:
a. Defina una clase de tareas para implementar la interfaz ejecutable, implementar el método run () en la interfaz ejecutable (el método run () le indica al hilo del sistema cómo ejecutar) y defina el código de tarea específico o la lógica de procesamiento en el método run ().
b. Después de definir la clase de tareas, cree un objeto de tarea para la clase de tareas.
do. La tarea debe ejecutarse en un hilo, crear un objeto de la clase de banda de rodadura y pasar el objeto de clase de tarea creado anteriormente que implementa la interfaz ejecutable al constructor de la clase de banda de rodadura como parámetro.
d. Llame al método Start () del objeto de clase de la banda de rodadura e inicie un hilo. Hace que se ejecute el método Run () de la tarea. Cuando se ejecuta el método run (), el hilo terminará.
Código de ejemplo:
paquete com.muzeet.mutithread; // Cada tarea es una instancia de la interfaz runable. La tarea es un objeto ejecutable, y el hilo es un objeto que facilita la ejecución de la tarea. Debe crear una clase de tareas y anular el método Ejecutar para definir la tarea de la clase pública ThreadDemo1 implementos runnable {private int Countdown = 10; @Override // Reescribe el método Ejecutar y defina la tarea public void run () {while (Countdown--> 0) {System.out.println ("$" + Thread.CurrentThread (). GetName () + "(" + Countdown + ")"); }} // Llamar al método de inicio iniciará un hilo, causando que se llame al método de ejecución en la tarea. Después de ejecutar el método de ejecución, el hilo termina el público void estático público (string [] args) {runnable demo1 = new ThreadDemo1 (); Thread Thread1 = nuevo hilo (demo1); Thread Thread2 = New Thread (demo1); Thread1.Start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Programa de ejecución de resultados:
ROCKET LANGAR ROTAWNDOWN: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-0 (5) $ Thread-0 (4) $ Thread-0 (3) $ Thread-0 (2) $ Thread-0 (1) $ Thread-0 (0)
Ejecute dos objetos de tarea al mismo tiempo:
public static void main (string [] args) {runnable demo1 = new ThreadDemo1 (); Runnable demo2 = new ThreadDemo1 (); Thread Thread1 = nuevo hilo (demo1); Thread Thread2 = New Thread (demo2); Thread1.Start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }Resultados de ejecución:
Countdown de lanzamiento de cohetes: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-1 (9) $ Thread-0 (5) $ Thread-1 (8) $ Thread-0 (4) $ Thread-1 (7) $ Thread-0 (3) $ Thread-1 (6) $ Thread-1 (5) $ Thread-0 (2) $ Thread-1 (4) $ Thread-1 (3) $ Thread-1 (2) $ Thread-1 (1) $ Thread-1 (0) $ Thread-0 (1) $ Thread-0 (0)
(3) Heredar la clase de hilo para crear un hilo:
a. Primero crear una clase de tareas extiende la clase de hilo. Debido a que la clase de subprocesos implementa la interfaz Runnable, la clase de tareas personalizada también implementa la interfaz ejecutable y el método Rerun (), que define un código de tarea específico o lógica de procesamiento.
b. Cree un objeto de clase de tareas, que puede usar Thread o Runnable como un tipo de variable personalizado.
do. Llame al método Start () del objeto personalizado e inicie un hilo.
Código de muestra:
paquete com.muzeet.mutithread; // Cada tarea es una instancia de la interfaz runable. La tarea es un objeto ejecutable, y el hilo puede ejecutar el objeto. Se debe crear la clase de tareas, y el método de ejecución debe anularse para definir la clase pública de tarea ExtendFomThread extiende el hilo {private int Countdown = 10; @Override // Reescribe el método Ejecutar y defina la tarea public void run () {while (Countdown--> 0) {System.out.println ("$" + this.getName () + "(" + Countdown + ")"); }} // Llamar al método de inicio iniciará un hilo, causando que se llame al método de ejecución en la tarea. Después de ejecutar el método Ejecutar, el hilo termina el público void estático público (string [] args) {ExtendFromThread Thread1 = new ExtendFromThread (); ExtendFromThread Thread2 = new ExtendFromThread (); Thread1.Start (); thread2.start (); System.out.println ("Rocket Launch Countdown:"); }}Resultados de ejecución:
Countdown de lanzamiento de cohetes: $ Thread-0 (9) $ Thread-0 (8) $ Thread-0 (7) $ Thread-0 (6) $ Thread-0 (5) $ Thread-0 (4) $ Thread-0 (3) $ Thread-0 (2) $ Thread-0 (1) $ Thread-0 (0) $ Thread-1 (9) $ Thread-1 (8) $ Thread-1 (7) $ Thread-1 (6) $ Thread-1 (5) $ Thread-1 (4) $ Thread-1 (3) $ Thread-1 (2) $ Thread-1 (1) $ Thread-1 (0)
Un hilo espera a que finalice otro hilo antes de ejecutar: al ejecutar la tarea PrintNum, al imprimir el número 50, se convierte en ejecutar la tarea de imprimir el carácter C, y solo entonces continúa ejecutando la tarea de imprimir el número después de que se haya ejecutado el subproceso.
paquete com.muzeet.testthread; public class printnum implements runnable {private int lastNum; Public printnum (int n) {lastNum = n; } @Override public void run () {// TODO Auto Generado Método STUB Thread4 = New Thread (new PrintChar ('C', 40)); Thread4.Start (); Pruebe {para (int i = 1; i <= lastNum; i ++) {System.out.println (""+i); if (i == 50) {thread4.join (); }}} Catch (InterruptedException e) {// TODO BLOQUE DE CABTA AUTO GENERADA E.PRINTSTACKTRACE (); }}}4. Comparación de los dos métodos (reimpreso)
Primero, analizamos los resultados de salida de los dos métodos. También creamos dos hilos. ¿Por qué los resultados son diferentes?
Usando la interfaz Runnable para crear hilos, puede compartir el mismo objeto de destino (TreadDemo1tt = newtreadDemo1 ();), implementando múltiples hilos idénticos para procesar el mismo recurso. Cuando el primer hilo completa la tarea, Countdown ya es 0, por lo que el segundo subproceso no saldrá. Heredando el método de crear subproces por hilo, se crean dos objetos de clase de tareas, con sus respectivas variables de miembros, y no interfieren entre sí.
Luego mira una explicación de JDK:
La interfaz ejecutable debe implementarse mediante clases que tengan la intención de ejecutar sus instancias a través de un cierto hilo. La clase debe definir un método sin parámetros llamado Run.
El propósito de diseñar esta interfaz es proporcionar un protocolo público para los objetos que desean ejecutar código cuando está activo. Por ejemplo, la clase de hilo implementa Runnable. La activación significa que se ha iniciado un hilo y aún no se ha detenido.
Además, Runnable proporciona un método de activación para clases que no son subclases de hilo. Al instancias de una instancia de hilo y tomarse como el objetivo en ejecución, puede ejecutar una clase que implementa Runnable. En la mayoría de los casos, si solo desea anular el método Run () y no anular otros métodos de subprocesos, debe usar la interfaz ejecutable. Esto es importante porque a menos que el programador tenga la intención de modificar o mejorar el comportamiento básico de una clase, no se debe crear una subclase para esa clase. (Se recomienda utilizar la creación de una clase de tareas e implementar la interfaz ejecutable en lugar de heredar la clase de subprocesos)
Adoptar la herencia de la clase de hilo:
(1) Ventajas: fácil de escribir. Si necesita acceder al hilo actual, no necesita usar el método thread.currentThread (). Puede obtener el hilo actual directamente usando esto.
(2) Desventajas: Debido a que la clase de hilo ha heredado la clase de subprocesos, no puede heredar otras clases de padres.
Uso del método de interfaz ejecutable:
(1) Ventajas: las clases de subprocesos solo implementan la interfaz ejecutable y también pueden heredar otras clases. De esta manera, múltiples hilos pueden compartir el mismo objeto objetivo, por lo que es muy adecuado para que múltiples hilos idénticos manejen el mismo recurso, de modo que el código y los datos de la CPU se pueden separar para formar un modelo claro, que refleja mejor la idea orientada al objeto.
(2) Desventajas: la programación es un poco complicada. Si necesita acceder al hilo actual, debe usar el método Thread.CurrentThread ().
Resumir
Lo anterior se trata de las dos formas de crear hilos en ejemplos de código multithreading y código comparativo de Java. Espero que sea útil para todos. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!