S12L02 - Creando un hilo extendiendo la clase Thread

html

Creando Aplicaciones Multihilo: Una Guía Completa
Tabla de Contenidos

1. Introducción ................................................................................... 3
2. Comprender las Aplicaciones Multihilo ... 5

2.1 ¿Qué es el Multihilo? .................................... 6
2.2 Beneficios del Multihilo .......................... 7
2.3 Métodos Clave en el Multihilo .................... 8

3. Construyendo una Aplicación Multihilo ............... 10

3.1 Configurando el Proyecto .......................................... 11
3.2 Creando la Clase MyCounter ............................ 13
3.3 Implementando el Método Main ............................ 16
3.4 Añadiendo Thread Sleep .................................................... 19
3.5 Midiendo el Tiempo de Ejecución .................................... 21

4. Ejecución Síncrona vs. Multihilo .... 24
5. Conclusión ................................................................................... 28
6. Recursos Adicionales ....................................................... 29

---
Introducción
En el mundo en rápida evolución del desarrollo de software, comprender cómo gestionar múltiples tareas simultáneamente de manera efectiva es crucial. Las aplicaciones multihilo permiten a los desarrolladores realizar múltiples operaciones concurrentemente, mejorando el rendimiento y la capacidad de respuesta. Este eBook profundiza en las complejidades de las aplicaciones multihilo, guiándote a través de la creación de un programa multihilo sencillo. Ya seas un principiante o un desarrollador con conocimientos básicos, esta guía ofrece un camino claro y conciso para dominar el multihilo en Java.
---
Comprender las Aplicaciones Multihilo
¿Qué es el Multihilo?
El multihilo es una técnica de programación que permite que múltiples threads se ejecuten concurrentemente dentro de un solo proceso. Cada thread representa una ruta de ejecución independiente, permitiendo que las tareas se realicen simultáneamente. Esto es particularmente beneficioso para aplicaciones que requieren alto rendimiento y capacidad de respuesta, como servidores web, motores de juegos y sistemas de procesamiento de datos en tiempo real.
Beneficios del Multihilo


Beneficio
Descripción


Rendimiento Mejorado
Permite que múltiples operaciones se ejecuten en paralelo, reduciendo el tiempo total de ejecución.


Mejora en la Capacidad de Respuesta
Mantiene las aplicaciones receptivas al realizar tareas de fondo sin interrumpir el proceso principal.


Utilización de Recursos
Maximiza el uso de la CPU distribuyendo tareas a través de múltiples threads.


Escalabilidad
Facilita la creación de aplicaciones escalables capaces de manejar cargas de trabajo aumentadas.


Métodos Clave en el Multihilo
Comprender los métodos fundamentales asociados con el multihilo es esencial para una implementación efectiva. Algunos de los métodos clave incluyen:

start(): Inicia un nuevo thread.
run(): Contiene el código que el thread ejecuta.
sleep(long millis): Pausa el thread durante una duración especificada.
wait(): Hace que el thread actual espere hasta que otro thread invoque notify().
yield(): Sugiere que el thread actual está dispuesto a ceder su uso actual de un procesador.

Estos métodos forman la base de la gestión y sincronización de threads en Java.
---
Construyendo una Aplicación Multihilo
Configurando el Proyecto
Para comenzar a construir nuestra aplicación multihilo, configuraremos un proyecto Java. Asegúrate de tener instalado el Java Development Kit (JDK) en tu máquina. Utilizar un Entorno de Desarrollo Integrado (IDE) como IntelliJ IDEA o Eclipse puede simplificar el proceso.
Estructura del Proyecto:




		
		
			
			
Java
			
			S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						S12L02 - Creating thread by extending the thread class/
├── pom.xml
├── src/
│   ├── main/
│   │   └── java/
│   │       └── org/
│   │           └── studyeasy/
│   │               ├── Main.java
│   │               └── MyCounter.java
│   └── test/
│       └── java/
├── target/
					
				
			
		


Nota: El archivo pom.xml se utiliza para la configuración del proyecto en Maven.
Creando la Clase MyCounter
La clase MyCounter sirve como la base de nuestra aplicación multihilo. Contiene la lógica para contar y mostrar los valores de iteración.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Método para realizar la cuenta
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Método para realizar la cuenta
    public void countMe() {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
        }
    }
}
 
					
				
			
		


Explicación:

threadNumber: Identifica el thread, ayudando a distinguir la salida de múltiples threads.
Constructor: Inicializa el threadNumber.
countMe(): Itera de 0 a 9, imprimiendo el número del thread actual y el conteo de iteración.

Implementando el Método Main
La clase Main orquesta la creación y ejecución de múltiples instancias de MyCounter.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Mostrando separador
        System.out.println("**********");

        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Mostrando separador
        System.out.println("**********");
 
        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Explicación:

counter1 & counter2: Instancian objetos MyCounter con números de thread distintos.
countMe(): Invoca el método de conteo para cada contador.
Separador: Mejora la legibilidad al distinguir las salidas de diferentes threads.

Salida:




		
		
			
			
Java
			
			Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						Thread 1: Iteration 0
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
Thread 2: Iteration 1
...
Thread 2: Iteration 9
					
				
			
		


Añadiendo Thread Sleep
Para simular retrasos en el procesamiento y observar la ejecución síncrona, introduciremos el método sleep.




		
		
			
			
Java
			
			
package org.studyeasy;

public class MyCounter {
    private int threadNumber;

    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }

    // Método para realizar la cuenta con sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pausa el thread por 500 milisegundos
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
				
						 
package org.studyeasy;
 
public class MyCounter {
    private int threadNumber;
 
    // Constructor
    public MyCounter(int threadNumber) {
        this.threadNumber = threadNumber;
    }
 
    // Método para realizar la cuenta con sleep
    public void countMe() throws InterruptedException {
        for (int i = 0; i < 10; i++) {
            System.out.println("Thread " + threadNumber + ": Iteration " + i);
            Thread.sleep(500); // Pausa el thread por 500 milisegundos
        }
    }
}
 
					
				
			
		


Explicación:

Thread.sleep(500): Introduce una pausa de 500 milisegundos después de cada iteración, simulando tiempo de procesamiento.
throws InterruptedException: Indica que el método puede lanzar una InterruptedException, lo que requiere manejo de excepciones en el método main.

Método Main Actualizado:




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Mostrando separador
        System.out.println("**********");

        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Mostrando separador
        System.out.println("**********");
 
        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
    }
}
 
					
				
			
		


Salida con Sleep:




		
		
			
			
Java
			
			Thread 1: Iteration 0
(Thread se pausa por 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread se pausa por 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Tiempo total requerido para el procesamiento: 10 segundos
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Thread 1: Iteration 0
(Thread se pausa por 500ms)
Thread 1: Iteration 1
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
(Thread se pausa por 500ms)
Thread 2: Iteration 1
...
Thread 2: Iteration 9
Tiempo total requerido para el procesamiento: 10 segundos
					
				
			
		


Nota: El tiempo total se alinea con las duraciones de sleep acumuladas, destacando la ejecución síncrona.
Midiendo el Tiempo de Ejecución
Para evaluar el impacto del rendimiento de la sincronización, mediremos el tiempo total de ejecución.




		
		
			
			
Java
			
			
package org.studyeasy;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();

        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();

        // Mostrando separador
        System.out.println("**********");

        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();

        long endTime = System.currentTimeMillis();
        System.out.println("Tiempo total requerido para el procesamiento: " + (endTime - startTime)/1000 + " segundos");
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
				
						 
package org.studyeasy;
 
public class Main {
    public static void main(String[] args) throws InterruptedException {
        long startTime = System.currentTimeMillis();
 
        // Creando el primer contador
        MyCounter counter1 = new MyCounter(1);
        counter1.countMe();
 
        // Mostrando separador
        System.out.println("**********");
 
        // Creando el segundo contador
        MyCounter counter2 = new MyCounter(2);
        counter2.countMe();
 
        long endTime = System.currentTimeMillis();
        System.out.println("Tiempo total requerido para el procesamiento: " + (endTime - startTime)/1000 + " segundos");
    }
}
 
					
				
			
		


Explicación:

startTime & endTime: Capturan el tiempo actual del sistema antes y después de la ejecución.
Cálculo del Tiempo Total: Resta startTime de endTime para determinar la duración total del procesamiento.

Salida de Muestra:




		
		
			
			
Java
			
			Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Tiempo total requerido para el procesamiento: 10 segundos
			
				
					
				
					1
2
3
4
5
6
7
8
				
						Thread 1: Iteration 0
...
Thread 1: Iteration 9
**********
Thread 2: Iteration 0
...
Thread 2: Iteration 9
Tiempo total requerido para el procesamiento: 10 segundos
					
				
			
		


Nota: El tiempo total se alinea con las duraciones de sleep acumuladas, destacando la ejecución síncrona.
---
Ejecución Síncrona vs. Multihilo
En la implementación actual, la aplicación se ejecuta de manera síncrona, lo que significa que cada thread completa su ejecución antes de que el siguiente comience. Esto resulta en un tiempo de procesamiento acumulativo proporcional al número de threads.
Características de la Ejecución Síncrona:

Procesamiento Secuencial: Un thread se ejecuta a la vez.
Comportamiento Predecible: Fácil de seguir el flujo de ejecución.
Tiempo de Procesamiento más Largo: El tiempo total aumenta con el número de threads.

Ventajas de la Ejecución Multihilo:

Procesamiento Concurrente: Múltiples threads se ejecutan simultáneamente.
Reducción del Tiempo Total: El tiempo de ejecución disminuye a medida que los threads operan en paralelo.
Mejora en la Capacidad de Respuesta: Las aplicaciones permanecen receptivas, especialmente en aplicaciones de GUI.

Para pasar de una ejecución síncrona a una ejecución multihilo, utilizaremos la clase Thread de Java o implementaremos la interfaz Runnable, permitiendo que los threads se ejecuten concurrentemente.
---
Conclusión
Esta guía proporcionó una comprensión fundamental de las aplicaciones multihilo en Java. Al crear una clase MyCounter sencilla y orquestar su ejecución en la clase Main, exploramos los conceptos básicos de la creación de threads, la sincronización y la medición del rendimiento. Mientras que el enfoque síncrono ofrece simplicidad, adoptar el multihilo puede mejorar significativamente el rendimiento y la capacidad de respuesta de las aplicaciones. A medida que continúes tu viaje, profundizar en la gestión de threads, los mecanismos de sincronización y las utilidades avanzadas de concurrencia te permitirá construir aplicaciones robustas y eficientes.
Palabras Clave para SEO: aplicaciones multihilo, Java multi-threading, gestión de threads, ejecución síncrona, Thread.sleep, clase Thread de Java, concurrencia en Java, mejorando el rendimiento de la aplicación, guía para principiantes de multihilo, creando threads en Java
Nota: Este artículo es generado por IA.









---
Recursos Adicionales

Documentación de Java de Oracle: Threads
Java Concurrency in Practice de Brian Goetz
TutorialsPoint: Java Multihilo
Baeldung: Introducción a Threads en Java
GeeksforGeeks: Multihilo en Java
Beneficio	Descripción
Rendimiento Mejorado	Permite que múltiples operaciones se ejecuten en paralelo, reduciendo el tiempo total de ejecución.
Mejora en la Capacidad de Respuesta	Mantiene las aplicaciones receptivas al realizar tareas de fondo sin interrumpir el proceso principal.
Utilización de Recursos	Maximiza el uso de la CPU distribuyendo tareas a través de múltiples threads.
Escalabilidad	Facilita la creación de aplicaciones escalables capaces de manejar cargas de trabajo aumentadas.
---