Este artículo es un resumen del uso básico de Java multithreading.
Este artículo explicará el uso básico de Java multithreading de los siguientes aspectos:
Cómo usar múltiples lectura
Dos formas de iniciar un hilo
Java proporciona dos formas de usar múltiples subprocesos. Una es escribir una clase para heredar el hilo, luego sobrescribir el método Ejecutar y luego llamar al método de inicio para iniciar el hilo. En este momento, esta clase ejecutará el código en el método Ejecutar en la forma en que otro hilo. Otra forma es escribir una clase para implementar la interfaz ejecutable, luego implementar la ejecución del método de interfaz y luego crear un objeto de subproceso, usar la clase que implementa la interfaz ejecutable como un parámetro de construcción, pasarlo al objeto de subproceso y finalmente el objeto de subproceso llama al método de inicio.
El método de inicio aquí es un método con la función de inicio, que llama internamente el método Ejecutar. Por lo tanto, solo cuando se llama el método de inicio, se iniciará otro hilo, el método de ejecución se llamará directamente o se ejecutará en el mismo hilo, en lugar de ejecutar en otro hilo
Además, el método de inicio solo le dice a la máquina virtual que se puede iniciar el hilo, lo que significa que el hilo está en el estado listo, pero no significa que la llamada al inicio se ejecute de inmediato. Esto requiere esperar que el JVM decida cuándo ejecutar el hilo. En otras palabras, si hay dos hilos A y B, A las llamadas comienzan primero, y las llamadas B comienzan más tarde, no significa que el hilo A funcione primero, y el hilo B funciona más tarde. Todo esto está determinado por el JVM y puede considerarse un inicio aleatorio.
A continuación usamos el código real para ilustrar dos formas de iniciar hilos:
El primer tipo es heredar el hilo
La clase pública Ejemplethread extiende el hilo {@Override public void run () {super.run (); System.out.println ("Este es un ejemplo de hilo"); }}El código de prueba se puede encontrar en la clase EjemplPplethreadTest en el directorio de prueba
Otra forma, implementa la interfaz ejecutable
Public Class Expplerunable implementos runnable {public void run () {System.out.println ("Esta es la clase que implementa la interfaz runnable"); }}Para el código de prueba, puede ver la clase EjemplerUnUnableTest en el directorio de prueba.
Cómo obtener información sobre múltiples lectura
Después de comenzar el subproceso múltiple, esperamos obtener información sobre el hilo iniciado a través de algunas API. JDK nos proporciona un método de clase de subproceso para obtener información sobre el hilo.
Obtenga el nombre del hilo
Estos métodos son métodos internos de hilo, por lo que podemos llamar a estos métodos de dos maneras. Una es que cuando nuestra clase hereda el hilo para usar múltiples subprocesos, podemos usar esto para llamarlo. Otra forma es llamar a estos métodos a través de Thread.CurrentThread (). Sin embargo, estos dos métodos son diferentes en diferentes escenarios de uso.
Veamos brevemente el uso de dos métodos.
Se utiliza el primer hilo.currentThread (), el código es el siguiente:
Public Class ExpplecurrentThread extiende el hilo {public ExpplecUrentThread () {System.out.println ("Impresión del método Constructor:" + Thread.CurrentThread (). getName ()); } @Override public void run () {super.run (); System.out.println ("Imprimir el método de ejecución:" + Thread.CurrentThread (). GetName ()); }}El código de prueba es el siguiente:
Public Class ExpplecurrentThreadTest extiende TestCase {public void testInit () lanza la excepción {ExpplecurrentThread Thread = new ExppleCurrentThread (); } public void testRun () lanza la excepción {ExpLPLECURENTTHREAD thread = new ExpplecurrentThread (); Thread.Start (); Thread.sleep (1000); }}Los resultados son los siguientes:
Impresión del método del constructor: Impresión del método Mainrun: Impresión del método de construcción de hilo-0: principal
¿Por qué usamos Thread.CurrentThread () dentro de EjemploPplecurrentThread para mostrar que el método de construcción se imprime como principal, porque Thread.CurrentThread () devuelve la información de que ese hilo llama al segmento de código. Es obvio que el método de construcción es ejecutado por el hilo principal, y el método de ejecución es ejecutado por el hilo que comenzamos por nosotros mismos. Debido a que no se nombra, es Predeterminado Treus-0.
A continuación, estamos echando un vistazo a heredar del hilo y llamarlo con esto.
Public Class ComplexCurrentThread extiende el hilo {public ComplexCurrentThread () {System.out.println ("begin ==================="); System.out.println ("Thread.CurrentThread (). GetName =" + Thread.CurrentThread (). GetName ()); System.out.println ("this.getName () =" + this.getName ()); System.out.println ("end ===================================================);} @Override public void run () {super.run (); System.out.println (" Run Begin System.out.println ("Thread.CurrentThread (). GetName =" + Thread.CurrentThread (). GetName ());El código de prueba es el siguiente:
Public Class ComplexCurrentThreadTest extiende TestCase {public void testRun () lanza la excepción {ComplexCurrentThread Thread = new ComplexCurrentThread (); Thread.SetName ("Byhieg"); Thread.Start (); Thread.sleep (3000); }}Los resultados son los siguientes:
begin ============ Tread.CurrentThread (). getName = mainThis.getName () = Thread-0end ======================= CORREGE ========== SUXT.CurrentThread ().
En primer lugar, al crear el objeto, el constructor todavía es ejecutado por el hilo principal, por lo que hilo. CurrentThread () obtiene el nombre del hilo principal, pero este método se refiere al objeto que llama al método, es decir, la información del hilo de ComplexCurrentThread. Todavía no hay setname, por lo que es el nombre predeterminado. Entonces el método Ejecutar es Thread.CurrentThread () o esto devuelve la información del hilo con el conjunto de nombres de Byhieg.
Entonces, hilo. CurrentThread se refiere a la información del hilo que ejecuta específicamente este bloque de código. El constructor se ejecuta por main, y el método Ejecutar es qué hilo comienza y qué hilo se ejecuta ejecución. Desde este punto de vista, la información que esto puede obtener es inexacta, porque si ejecutamos esto.getName () en ejecución, pero el método de ejecución es iniciado por otro hilo, no podemos obtener la información de la nueva ciudad ejecutando el método de ejecución a través de este.getName. Y solo las clases que heredan el hilo pueden tener métodos como GetName, que es un desastre para los idiomas de características de Java que no tienen herencias múltiples. Para obtener toda la información sobre los hilos que queremos obtener después, usamos Thread.CurrentThread () para llamar a la API.
Obtener la identificación del hilo
Llame a GetID para obtener la identificación única del hilo. Esto es lo mismo que el uso de GetName arriba. No hay nada que decir. Puede mirar directamente EjemploIdThread y su clase de prueba EjemploidThreadTest.
Determinar si el hilo sobrevive
La función del método isalive () es probar si el hilo está activo. El llamado estado activo significa que el hilo se ha iniciado pero no ha terminado. Es decir, después de que comienza el hilo, se considera que está vivo.
Echemos un vistazo a ejemplos específicos:
public class Alivethread extiende el hilo {@Override public void run () {super.run (); System.out.println ("¿Está vivo en el método Ejecutar" + "" + Thread.CurrentThread (). Isalive ()); }}El método de prueba es el siguiente:
public class AlivethreadTest extiende TestCase {public void testRun () lanza la excepción {Alivethread Thread = new Alivethread (); System.out.println ("begin ==" + thread.isalive ()); Thread.Start (); Thread.sleep (1000); System.out.println ("end ==" + thread.isalive ()); Thread.sleep (3000); }}Los resultados son los siguientes:
begin == si trueend en el método falso == falso
Podemos encontrar que antes del inicio, el hilo se considera que no es seguido, y luego, cuando se ejecuta, está vivo. Cuando se ejecuta el método de ejecución, se considera que no es seguido.
Cómo detener un hilo
Determinar si el hilo ha terminado
JDK proporciona algunos métodos para determinar si el hilo está terminado: ISinterrupted () e interrumped ()
Cómo detener los hilos
Este es un método más importante para obtener información de subprocesos, ya que está relacionado con el método de terminar los subprocesos. Permítanme hablar primero sobre varias formas de terminar los hilos:
No hablaré sobre el primero, el segundo método stop () ha sido abandonado porque pueden ocurrir las siguientes razones:
Para ejemplos específicos, puede ver StopLockThread y su clase de prueba StopLockThreadTest
El tercer tipo es el método de terminación actualmente recomendado, llamando a la interrupción y luego determinar si finalizar en el método Ejecutar. Hay dos formas de juzgar la terminación. Uno es el método estático interrumpido () de la clase de subprocesos, y el otro es el método de miembro del subproceso ISinterrupted (). Hay una diferencia entre estos dos métodos. El primer método restablecerá automáticamente el estado. Si se interrumpe () se llama dos veces seguidas, si es falsa la primera vez, la segunda vez debe ser verdadera. E ISinterrupted () no lo hará.
Los ejemplos son los siguientes:
public class EjemplointerruptThread extiende el hilo {@Override public void run () {super.run (); Pruebe {for (int i = 0; i <50000000; i ++) {if (interrupted ()) {System.out.println ("Ya es un estado de parada, quiero salir"); arrojar una nueva interrupciónxception ("parar ......"); } System.out.println ("i =" + (i + 1)); }} capt (interruptedException e) {system.out.println ("pare suavemente"); }}}El código de prueba es el siguiente:
Public Class EjemplointerruptThreadTest extiende TestCase {public void testRun () lanza la excepción {EjemplointerruptThread thread = new EjemploInterruptThread (); Thread.Start (); Thread.sleep (1000); Thread.interrupt (); }}El cuarto método es el mismo que el tercero. La única diferencia es reemplazar la excepción lanzada en el código anterior con retorno. Todavía me gusta arrojar excepciones. Aquí hay muchas formas de procesamiento, como imprimir información, cerrar o capturar el recurso y luego arrojarlo a la capa superior nuevamente.
Tenga en cuenta que la excepción que organizamos anteriormente es una Cuercenta InterruptedEx. Aquí hablamos brevemente sobre las razones por las cuales se puede generar esta excepción. En el caso del sueño del hilo original, llame a la interrupción para terminar el hilo o termine el hilo primero y luego deje que el hilo duerma.
Cómo pausar el hilo
Los siguientes dos métodos se proporcionan en el JDK para pausar hilos y restaurar hilos.
Estos dos métodos son métodos abandonados como el método de parada, y su uso es el mismo que la parada, suspender brutalmente hilos y restaurar los hilos. Las razones principales por las que estos dos métodos son abandonados son:
Algunos otros usos de hilos
Algunos otros usos básicos de hilos son los siguientes:
Concesiones de hilo
JDK proporciona el método de rendimiento () para que el hilo renuncie al recurso actual de la CPU y lo entregue a otras tareas para ocupar el tiempo de CPU, pero esto también es algo aleatorio. Es posible que tome la porción de tiempo justo después de renunciar a los recursos.
Para ejemplos específicos, consulte ExampLeyEngieldThread y su clase de prueba ExampLeyEngieldThreadTest
Establezca la prioridad de los hilos
Podemos establecer la prioridad de los subprocesos para permitir que la CPU lo sea posible para enviar los recursos de ejecución a los subprocesos con mayor prioridad. Java establece 1-10 10 niveles de prioridad, y hay tres variables estáticas para proporcionar tres niveles de prioridad:
/*** La prioridad mínima que puede tener un hilo. */ public Final Static int min_priority = 1; /*** La prioridad predeterminada que se asigna a un hilo. */ public final static int norm_priority = 5; /*** La prioridad máxima que puede tener un hilo. */ public final static int max_priority = 10;
Podemos establecer la prioridad del hilo a través de SetPriority, y podemos pasar directamente en tres variables estáticas para apelar, o pasar directamente en los números 1-10. Después de la configuración, el hilo tendrá diferentes prioridades. ¿Qué sucede si no establecemos prioridad?
La prioridad de los hilos se hereda. Si comenzamos el hilo B en el hilo A, AB tiene la misma prioridad. En general, cuando comenzamos un hilo en el hilo principal, tenemos una prioridad constante con el hilo principal. La prioridad del hilo principal es 5 por defecto.
Aquí hay algunas reglas para la prioridad:
Hilo
El JDK proporciona un método SetDaemon para establecer un hilo para convertirse en un hilo de demonio. La característica de los hilos de demonio es que después de que se ejecutan otros hilos no dadones, los hilos de demonio se destruirán automáticamente. Un ejemplo típico es el reciclador GC.
Para más detalles, puede ver EjempledAemonThread y EjempledAemonThreadTest.
Resumir
Este artículo resume principalmente algunos usos básicos de los hilos de Java, y se incluye en el segundo artículo sobre seguridad y sincronización de hilos.
Lo anterior es todo el contenido de este artículo. Espero que el contenido de este artículo sea de ayuda para el estudio o el trabajo de todos. ¡También espero apoyar a Wulin.com más!