Breve reseña sobre JAVA PROGRAM MULTI THREADING

 


Descripción general de Threading

El concepto de threading es muy importante en el lenguaje de programación Java. Un subproceso es una ruta secuencial de ejecución de código dentro de un programa. Y cada subproceso tiene sus propias variables locales, contador de programa y vida útil. En Java, un objeto de la clase thread puede representar un thread que se puede implementar a través de cualquiera de dos maneras: el uso de hilos en Java permitirá una mayor flexibilidad del programador que busca esa ventaja extra en sus programas. La simplicidad de crear, configurar y ejecutar subprocesos permite que el dispositivo del programador Java sea portátil y potente applets / aplicaciones que no se pueden hacer en otros lenguajes de tercera generación. Los subprocesos permiten que cualquier programa realice varias tareas a la vez. En un lenguaje consciente de Internet como Java, esta es una herramienta muy importante.

Introducción:

Un subproceso se define como una implementación de flujo separada que tiene lugar simultáneamente con y de forma independiente de todo lo demás que pueda estar sucediendo. No tiene un bucle de eventos. Un subproceso se ejecuta de forma autónoma de cualquier otra cosa que suceda en la computadora. Con los subprocesos, las otras tareas que no se atascan en el bucle pueden continuar procesando sin esperar a que finalice la tarea atascada. Un subproceso es una codificación que no afecta a la arquitectura de una aplicación. El subproceso está igualmente separado de una aplicación. El subproceso es separar igualmente la potencia de la computadora entre diferentes tareas.

 

Ciclo de vida del roscado:

Cuando se está programando con hilos entender el ciclo de vida del hilo es muy importante o valioso. Mientras un hilo está vivo, está en uno de varios estados. Al invocar el método start (), no significa que el subproceso tenga acceso a la CPU y comience a ejecutarse de inmediato. Varios factores determinan cómo procederá.

Ciclo de vida del hilo

1. Nuevo estado: después de la construcción de la instancia de subproceso, el subproceso está en este estado, pero antes de la invocación del método start (). En este punto, el hilo se considera no vivo.


2. Estado ejecutable (lectura a ejecución): un subproceso comienza su vida útil desde el estado ejecutable. El primer estado ejecutable del subproceso después puede volver a este estado después de ejecutarse, esperar, dormir o volver del estado bloqueado también. En este estado, un subproceso está esperando un encendido en el procesador.


3. Estado de ejecución: un subproceso está en estado de ejecución, lo que significa que el subproceso está esperando actualmente. Hay numerosas maneras de entrar en el estado Runnable, pero sólo hay una forma de entrar en el estado en ejecución: el programador selecciona un subproceso del grupo ejecutable.


4. Estado muerto: un subproceso puede considerarse muerto cuando se completa el método run (). Si algún subproceso aparece en este estado, significa que no puede volver a ejecutarse.


5. Bloqueado - Un hilo una entrada en este estado debido a la espera de los recursos que son sagrados por otro hilo.

 

Ventaja del multithreading sobre la multitarea:

Reducir el tiempo de cálculo

Mejora el rendimiento de una aplicación

Los subprocesos distribuyen el mismo espacio de direcciones para que ahorre memoria.

El cambio de contexto entre subprocesos suele ser menos costoso que entre procesos.

El costo de la comunicación entre hilos es comparativamente bajo.

Creación de hilos y programas sencillos:

En Java, un objeto de la clase thread puede representar un thread. El subproceso se puede implementar a través de cualquiera de dos maneras:

Ampliación del archivo java.lang. clase thread implementando java.lang. Interfaz ejecutable.



a. Extensión de Java.lang. clase thread

          Sintaxis: clase Mythread extend Thread


b. Implementación de java.lang. Interfaz ejecutable

                   Sintaxis: MyThread implementa Runnable.

{

}

c. Después de la declaración de la clase de subproceso, tenemos que anular el método run () en la clase.

d. Ahora podemos crear objeto de hilo si es necesario. En definitiva tenemos que seguir estos pasos:


1. Extienda el java.lang. clase thread


2. Invalide el método run () en la subclase de la clase de subproceso para definir el código ejecutado por el subproceso.


3. Crea un instante de esta subclase. Esta subclase puede llamar a un constructor de clase de subproceso por constructor de subclase.


4. Invoque el método start () en la instancia de la clase para que el subproceso sea elegible para ejecutarse.


La siguiente programación muestra la creación de un solo subproceso que extiende la clase " Thread ".

Subproceso de extensión de clase MyThread

{

Cadenas=null;

MyThread (cadena s 1)

{

S=s1:

Inicio ();

}

Ejecución pública de vacío ()

{

System.out.println (s);

}

}

Clase pública Run Thread

{

Clase pública Run Thread

{

MyThread m1 = nuevo MyThread ("Thread start....");

}

}

 

El resultado del programa es:


C:> subproceso de ejecución de JAVA. Java

C:> Java Run Thread

Hilo iniciado....

II. Implementación de la interfaz Java.lang.Runable El procedimiento para crear subprocesos mediante la implementación de la interfaz Runnable es el siguiente:


1. Una clase implementa la interfaz Runnable, invalida el método run () para definir el código ejecutado por el subproceso. Un objeto de esta clase es Runnable object.


2. Cree un objeto de clase de subproceso pasando un objeto Runnable como argumento.


3. Invoque el método start () en la instancia de la clase de subproceso.


El siguiente programa muestra la creación de subprocesos implementando la interfaz Runnable:

Clase Thr 1 implementa Runnable {

Hilo t;

Cadena s=null;

Thr 1(cadena s 1){

S=s 1;

t=nuevo hilo (esto);

t.start();

}

Corrida pública nula () {

System.out.printin (s);

}

}

Subproceso ejecutable de clase pública {

Clase pública void main (string args[ ] ) {

Thr 1 m 1 = nuevo el 1 ("Hilo iniciado...."):

}

}

 

Salida:


C:> Java Runnable thread.java

C:> Subproceso ejecutable de Java

Hilo iniciado....

Sin embargo, este programa devuelve la misma salida que la salida generada a través del programa anterior, hay dos razones para implementar una interfaz Runnable preferible a extender la clase Thread:

Si extiende la clase de subproceso, eso significa que la subclase no puede extender ninguna otra clase, pero si implementa una interfaz ejecutable, puede hacerlo.

La clase que implementa la interfaz ejecutable puede evitar la sobrecarga completa de la clase de subproceso, que puede ser excesiva.

Join() is Alive () métodos:

El siguiente programa demuestra los métodos join() y is alive ():

Class Demo alive extiende Threads {

Valor Int;

Demo pública viva (string str)

{

Super {str};

Valor= ();

Inicio ()

}

Ejecución pública de vacío ()

{

Probar

{

Mientras que (valor<5){

System.out.printin(get Name ()+ " " + (value++));

Thread.sleep(250);

}

} Captura (Excepción e ) { }

System.out.printIn (" Salir del subproceso:"+ getName ());

}

}

Vacío estático público principal (string [ ] args)

{

Demo Alive da = nuevo Demo Alive ("hilo a");

Demo Alive da = nuevo Demo Alive ("hilo b");

Probar

{

System.out.printIn("espere a que finalice el subproceso secundario");

da.join()

Si (!da.isAlive())

System.out.printIn("hilo A no vivo");

db.join();

Si (!db.is.Alive())

System.out.printIn("el hilo B no está vivo");

}Captura (Excepción e) { }

System.out.printIn("Salir del subproceso principal");

}

  }

 

Salida:


C:> Unirse a la demostración de Java.java

C:> Unirse a java demo

Espere a que finalicen los subprocesos secundarios.

Hilo a: 0

Rosca b: 0

Hilo a: 1

Rosca b: 1

Hilo a: 2

Rosca b: 2

Hilo a: 3

Hilo b: 3

Rosca a: 4

Rosca b: 4

Salir del subproceso: Subproceso a

El hilo A no está vivo

Salida del subproceso: Subproceso b

El hilo B no está vivo

Salida del hilo principal

 

Post a Comment

0 Comments