Múltiples subprocesos en Java: cómo comenzar con subprocesos

¿Qué es un hilo?

Un hilo es un proceso ligero. Cualquier proceso puede tener varios subprocesos ejecutándose.

Por ejemplo, en un navegador web, podemos tener un hilo que cargará la interfaz de usuario y otro hilo que realmente recuperará todos los datos que deben mostrarse en esa interfaz.

¿Qué es MultiThreading?

El subproceso múltiple nos permite ejecutar varios subprocesos al mismo tiempo.

Por ejemplo, en un navegador web, podemos tener un hilo que maneja la interfaz de usuario y, en paralelo, podemos tener otro hilo que recupera los datos que se mostrarán.

Entonces, el multihilo mejora la capacidad de respuesta de un sistema.

¿Qué es la concurrencia?

La concurrencia en el contexto de subprocesos nos permite ejecutar varios subprocesos al mismo tiempo.

Pero, ¿los hilos realmente se ejecutan al mismo tiempo?

Sistemas de un solo núcleo

El programador de subprocesos proporcionado por la JVM decide qué subproceso se ejecuta en un momento dado. El planificador da una pequeña porción de tiempo a cada hilo.

Entonces, en un momento dado, solo tenemos un hilo que se está ejecutando en el procesador. Pero debido a la división del tiempo, tenemos la sensación de que se están ejecutando varios subprocesos al mismo tiempo.

Sistemas de múltiples núcleos

Incluso en sistemas de múltiples núcleos, el programador de subprocesos está involucrado. Pero como tenemos varios núcleos, en realidad podemos tener varios subprocesos ejecutándose al mismo tiempo.

Por ejemplo, si tenemos un sistema de doble núcleo, entonces podemos tener 2 subprocesos ejecutándose exactamente al mismo tiempo. El primer hilo se ejecutará en el primer núcleo y el segundo hilo se ejecutará en el segundo núcleo.

¿Por qué se necesita el subproceso múltiple?

El subproceso múltiple nos permite mejorar la capacidad de respuesta de un sistema.

Por ejemplo, en un navegador web, si todo se ejecutara en un solo hilo, el sistema no respondería por completo cuando se buscaran datos para mostrarlos. Por ejemplo, si se necesitan 10 segundos para obtener los datos, en esos 10 segundos no podremos hacer nada más en el navegador web, como abrir nuevas pestañas o incluso cerrar el navegador web.

Entonces, ejecutar diferentes partes de un programa en diferentes subprocesos al mismo tiempo ayuda a mejorar la capacidad de respuesta de un sistema.

Cómo escribir programas multiproceso en Java

Podemos crear hilos en Java usando lo siguiente

  • Ampliando la clase de hilo
  • Implementando la interfaz ejecutable
  • Implementar la interfaz invocable
  • Mediante el uso del marco ejecutor junto con tareas ejecutables y ejecutables

Analizaremos los invocables y el marco del ejecutor en un blog separado. En este artículo me centraré principalmente en extender la clase de subproceso e implementar la interfaz ejecutable.

Ampliación de la clase Thread

Para crear un fragmento de código que se pueda ejecutar en un hilo, creamos una clase y luego ampliamos la clase del hilo . La tarea que está realizando este fragmento de código debe colocarse en la función run () .

En el siguiente código, puede ver que worker es una clase que extiende la clase de hilo , y la tarea de imprimir números del 0 al 5 se realiza dentro de la función run () .

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

En el código anterior, Thread.currentThread (). GetName () se usa para obtener el nombre del hilo actual que está ejecutando el código.

Para crear un hilo , solo necesitamos crear una instancia de la clase trabajadora. Y luego podemos iniciar el hilo usando la función start () .

public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

En el código anterior, estamos creando 3 subprocesos (t1, t2 y t3) de la clase trabajadora. Entonces comenzamos los hilos usando la función start () .

Aquí está el código final para crear un hilo extendiendo una clase de hilo:

class Worker extends Thread { @Override public void run() { for (int i = 0; i <= 5; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class ThreadClassDemo { public static void main(String[] args) { Thread t1 = new Worker(); Thread t2 = new Worker(); Thread t3 = new Worker(); t1.start(); t2.start(); t3.start(); } } 

Aquí está el resultado que obtenemos al ejecutar el código anterior:

Salida de clase de hilo

Puede ver que los 3 hilos han impreso los números del 0 al 5.

También puede ver claramente en la salida que los 3 subprocesos no se ejecutan en ninguna secuencia en particular

Implementing the Runnable Interface

In order to create a piece of code which can be run in a thread, we create a class and then implement the runnable interface. The task being done by this piece of code needs to be put in the run() function.

In the below code you can see that RunnableWorker is a class which implements runnable interface, and the task of printing numbers 0 to 4 is being done inside the run() function.

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } 

In order to create a thread, first we need to create an Instance of RunnableWorker which implements the runnable interface.

Then we can create a new thread by creating an instance of the thread class and passing the instance of RunnableWorker as the argument. This is shown in the code below:

public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

The above code creates a runnable instance r. Then it create 3 threads (t1, t2 and t3) and passes r as the argument to the 3 threads. Then the start() function is used to start all 3 threads.

Here is the complete code for creating a thread by implementing the runnable interface:

class RunnableWorker implements Runnable{ @Override public void run() { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } } } public class RunnableInterfaceDemo { public static void main(String[] args) { Runnable r = new RunnableWorker(); Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

On running the above code, we will get the following output. The sequence of the output will change every time the code is run.

Salida de interfaz ejecutable

Implementing the runnable interface is a better option than extending the thread class since we can extend only one class, but we can implement multiple interfaces in Java.

Runnable Interface in Java 8

In Java 8, the runnable interface becomes a FunctionalInterface since it has only one function, run().

The below code shows how we can create a runnable instance in Java 8.

public class RunnableFunctionalInterfaceDemo { public static void main(String[] args) { Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; Thread t1 = new Thread(r); Thread t2 = new Thread(r); Thread t3 = new Thread(r); t1.start(); t2.start(); t3.start(); } } 

Here, instead of creating a class and then implementing the runnable interface, we can directly use a lambda expression to create a runnable instance as shown below:

Runnable r = () -> { for (int i = 0; i <= 4; i++) { System.out.println(Thread.currentThread().getName() + ": " + i); } }; 

Code

The code in this article is available in the following GitHub repo: //github.com/aditya-sridhar/basic-threads-demo

Congrats ?

You now know how to create threads by extending the thread class and by implementing the runnable interface.

I will discuss the thread life cycle and challenges while using threads in my next blog post.

My Website: //adityasridhar.com/

No dude en conectarse conmigo en LinkedIn o seguirme en Twitter