Java:subprocesos múltiples
Java es un lenguaje de programación de subprocesos múltiples lo que significa que podemos desarrollar un programa de subprocesos múltiples usando Java. Un programa de subprocesos múltiples contiene dos o más partes que pueden ejecutarse simultáneamente y cada parte puede manejar una tarea diferente al mismo tiempo haciendo un uso óptimo de los recursos disponibles, especialmente cuando su computadora tiene múltiples CPU.
Por definición, la multitarea es cuando varios procesos comparten recursos de procesamiento comunes, como una CPU. Los subprocesos múltiples amplían la idea de la multitarea a aplicaciones en las que puede subdividir operaciones específicas dentro de una sola aplicación en subprocesos individuales. Cada uno de los subprocesos puede ejecutarse en paralelo. El sistema operativo divide el tiempo de procesamiento no solo entre diferentes aplicaciones, sino también entre cada subproceso dentro de una aplicación.
Los subprocesos múltiples le permiten escribir de una manera en la que varias actividades pueden realizarse simultáneamente en el mismo programa.
Ciclo de vida de un hilo
Un hilo pasa por varias etapas en su ciclo de vida. Por ejemplo, un subproceso nace, se inicia, se ejecuta y luego muere. El siguiente diagrama muestra el ciclo de vida completo de un hilo.
Las siguientes son las etapas del ciclo de vida −
-
Nuevo − Un nuevo hilo comienza su ciclo de vida en el nuevo estado. Permanece en este estado hasta que el programa inicia el hilo. También se conoce como hebra de nacimiento. .
-
Ejecutable − Después de que se inicia un subproceso recién nacido, el subproceso se vuelve ejecutable. Se considera que un subproceso en este estado está ejecutando su tarea.
-
Esperando − A veces, un subproceso pasa al estado de espera mientras el subproceso espera que otro subproceso realice una tarea. Un subproceso vuelve al estado ejecutable solo cuando otro subproceso indica al subproceso en espera que continúe ejecutándose.
-
Espera programada − Un subproceso ejecutable puede entrar en el estado de espera temporizado durante un intervalo de tiempo específico. Un subproceso en este estado vuelve al estado ejecutable cuando expira ese intervalo de tiempo o cuando ocurre el evento que está esperando.
-
Terminado (muerto) − Un subproceso ejecutable entra en el estado terminado cuando completa su tarea o termina de otro modo.
Prioridades de subprocesos
Cada subproceso de Java tiene una prioridad que ayuda al sistema operativo a determinar el orden en que se programan los subprocesos.
Las prioridades de subprocesos de Java están en el rango entre MIN_PRIORITY (una constante de 1) y MAX_PRIORITY (una constante de 10). De forma predeterminada, cada subproceso tiene prioridad NORM_PRIORITY (una constante de 5).
Los subprocesos con mayor prioridad son más importantes para un programa y se les debe asignar tiempo de procesador antes que los subprocesos de menor prioridad. Sin embargo, las prioridades de los subprocesos no pueden garantizar el orden en que se ejecutan los subprocesos y dependen en gran medida de la plataforma.
Cree un hilo implementando una interfaz ejecutable
Si su clase está destinada a ejecutarse como un hilo, puede lograrlo implementando un Ejecutable interfaz. Deberá seguir tres pasos básicos −
Paso 1
Como primer paso, debe implementar un método run() proporcionado por un Ejecutable interfaz. Este método proporciona un punto de entrada para el subproceso y colocará su lógica comercial completa dentro de este método. La siguiente es una sintaxis simple del método run() −
public void run( )
Paso 2
Como segundo paso, creará una instancia de un Subproceso objeto usando el siguiente constructor −
Thread(Runnable threadObj, String threadName);
Donde, threadObj es una instancia de una clase que implementa el Ejecutable interfaz y threadName es el nombre dado al nuevo hilo.
Paso 3
Una vez que se crea un objeto Thread, puede iniciarlo llamando a start() método, que ejecuta una llamada al método run( ). La siguiente es una sintaxis simple del método start() −
void start();
Ejemplo
Aquí hay un ejemplo que crea un nuevo hilo y comienza a ejecutarlo −
Demostración en vivo
class RunnableDemo implements Runnable {
private Thread t;
private String threadName;
RunnableDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
RunnableDemo R1 = new RunnableDemo( "Thread-1");
R1.start();
RunnableDemo R2 = new RunnableDemo( "Thread-2");
R2.start();
}
}
Esto producirá el siguiente resultado −
Salida
Creating Thread-1 Starting Thread-1 Creating Thread-2 Starting Thread-2 Running Thread-1 Thread: Thread-1, 4 Running Thread-2 Thread: Thread-2, 4 Thread: Thread-1, 3 Thread: Thread-2, 3 Thread: Thread-1, 2 Thread: Thread-2, 2 Thread: Thread-1, 1 Thread: Thread-2, 1 Thread Thread-1 exiting. Thread Thread-2 exiting.
Crear un hilo ampliando una clase de hilo
La segunda forma de crear un hilo es crear una nueva clase que amplíe Hilo clase utilizando los siguientes dos sencillos pasos. Este enfoque brinda más flexibilidad en el manejo de múltiples subprocesos creados con los métodos disponibles en la clase Subproceso.
Paso 1
Deberá anular ejecutar() disponible en la clase Thread. Este método proporciona un punto de entrada para el subproceso y colocará su lógica comercial completa dentro de este método. La siguiente es una sintaxis simple del método run() −
public void run( )
Paso 2
Una vez que se crea el objeto Thread, puede iniciarlo llamando a start() método, que ejecuta una llamada al método run( ). La siguiente es una sintaxis simple del método start() −
void start( );
Ejemplo
Aquí está el programa anterior reescrito para extender el hilo −
Demostración en vivo
class ThreadDemo extends Thread {
private Thread t;
private String threadName;
ThreadDemo( String name) {
threadName = name;
System.out.println("Creating " + threadName );
}
public void run() {
System.out.println("Running " + threadName );
try {
for(int i = 4; i > 0; i--) {
System.out.println("Thread: " + threadName + ", " + i);
// Let the thread sleep for a while.
Thread.sleep(50);
}
} catch (InterruptedException e) {
System.out.println("Thread " + threadName + " interrupted.");
}
System.out.println("Thread " + threadName + " exiting.");
}
public void start () {
System.out.println("Starting " + threadName );
if (t == null) {
t = new Thread (this, threadName);
t.start ();
}
}
}
public class TestThread {
public static void main(String args[]) {
ThreadDemo T1 = new ThreadDemo( "Thread-1");
T1.start();
ThreadDemo T2 = new ThreadDemo( "Thread-2");
T2.start();
}
}
Esto producirá el siguiente resultado −
Salida
Creating Thread-1 Starting Thread-1 Creating Thread-2 Starting Thread-2 Running Thread-1 Thread: Thread-1, 4 Running Thread-2 Thread: Thread-2, 4 Thread: Thread-1, 3 Thread: Thread-2, 3 Thread: Thread-1, 2 Thread: Thread-2, 2 Thread: Thread-1, 1 Thread: Thread-2, 1 Thread Thread-1 exiting. Thread Thread-2 exiting.
Métodos de subprocesos
A continuación se muestra la lista de métodos importantes disponibles en la clase Thread.
| Sr.No. | Método y descripción |
|---|---|
| 1 | inicio vacío público() Inicia el subproceso en una ruta de ejecución separada, luego invoca el método run() en este objeto Subproceso. |
| 2 | ejecución de vacío público() Si se creó una instancia de este objeto Thread utilizando un objetivo Runnable separado, el método run() se invoca en ese objeto Runnable. |
| 3 | public final void setName(String name) Cambia el nombre del objeto Thread. También hay un método getName() para recuperar el nombre. |
| 4 | setPriority de vacío final público (prioridad int) Establece la prioridad de este objeto Thread. Los valores posibles están entre 1 y 10. |
| 5 | setDaemon de vacío final público (booleano activado) Un parámetro de verdadero denota este subproceso como un subproceso daemon. |
| 6 | unión vacía final pública (milisegundos largos) El subproceso actual invoca este método en un segundo subproceso, lo que provoca que el subproceso actual se bloquee hasta que finaliza el segundo subproceso o pasa el número especificado de milisegundos. |
| 7 | interrupción de vacío público() Interrumpe este subproceso, lo que hace que continúe ejecutándose si se bloqueó por algún motivo. |
| 8 | booleano público final isAlive() Devuelve verdadero si el subproceso está vivo, que es cualquier momento después de que se haya iniciado el subproceso pero antes de que se complete. |
Los métodos anteriores se invocan en un objeto Thread en particular. Los siguientes métodos en la clase Thread son estáticos. La invocación de uno de los métodos estáticos realiza la operación en el subproceso que se está ejecutando actualmente.
| Sr.No. | Método y descripción |
|---|---|
| 1 | rendimiento de vacío estático público() Hace que el subproceso que se está ejecutando ceda el paso a cualquier otro subproceso de la misma prioridad que esté esperando a ser programado. |
| 2 | Sueño de vacío estático público (milisegundos largos) Hace que el subproceso que se está ejecutando se bloquee durante al menos el número especificado de milisegundos. |
| 3 | bloqueo booleano estático público (objeto x) Devuelve verdadero si el subproceso actual mantiene el bloqueo en el Objeto dado. |
| 4 | Subproceso estático público subproceso actual() Devuelve una referencia al subproceso que se está ejecutando actualmente, que es el subproceso que invoca este método. |
| 5 | vacío estático público dumpStack() Imprime el seguimiento de la pila del subproceso que se está ejecutando actualmente, lo que resulta útil al depurar una aplicación multiproceso. |
Ejemplo
El siguiente programa ThreadClassDemo muestra algunos de estos métodos de la clase Thread. Considere una clase DisplayMessage que implementa Ejecutable −
// File Name : DisplayMessage.java
// Create a thread to implement Runnable
public class DisplayMessage implements Runnable {
private String message;
public DisplayMessage(String message) {
this.message = message;
}
public void run() {
while(true) {
System.out.println(message);
}
}
}
A continuación se muestra otra clase que amplía la clase Thread −
// File Name : GuessANumber.java
// Create a thread to extentd Thread
public class GuessANumber extends Thread {
private int number;
public GuessANumber(int number) {
this.number = number;
}
public void run() {
int counter = 0;
int guess = 0;
do {
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
} while(guess != number);
System.out.println("** Correct!" + this.getName() + "in" + counter + "guesses.**");
}
}
El siguiente es el programa principal, que hace uso de las clases definidas anteriormente −
// File Name : ThreadClassDemo.java
public class ThreadClassDemo {
public static void main(String [] args) {
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();
Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(bye);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();
System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();
try {
thread3.join();
} catch (InterruptedException e) {
System.out.println("Thread interrupted.");
}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);
thread4.start();
System.out.println("main() is ending...");
}
}
Esto producirá el siguiente resultado. Puede probar este ejemplo una y otra vez y obtendrá un resultado diferente cada vez.
Salida
Starting hello thread... Starting goodbye thread... Hello Hello Hello Hello Hello Hello Goodbye Goodbye Goodbye Goodbye Goodbye .......
Conceptos principales de subprocesos múltiples de Java
Mientras realiza la programación de subprocesos múltiples en Java, necesitará tener muy a mano los siguientes conceptos:
-
¿Qué es la sincronización de subprocesos?
-
Manejo de la comunicación entre subprocesos
-
Manejar interbloqueo de subprocesos
-
Operaciones principales de subprocesos
Java