Aplicaciones Distribuidas

“SINCRONIZACIÓN DE THREADS”

Integrantes:

Alberto Carrera

Maycol Pacha

Juan José Ruiz

Tutor:

Ing. Mauricio Campaña

SANGOLQUÍ-ECUADOR
  CONTENIDO
1 ESTADOS DE LOS THREADS...................................................................................................................................4
1.1 NUEVO............................................................................................................................................................ 4
1.2 EJECUTABLE...................................................................................................................................................4
1.3 BLOQUEADO...................................................................................................................................................4
1.4 MUERTO............................................................................................................................................................4
2 EJERCICIO PRÁCTICO..................................................................................................................................................5
3 CÓDIGO PROGRAMA...............................................................................................................................................10
4 CONCLUSIONES.........................................................................................................................................................11
5 REFERENCIAS..............................................................................................................................................................11
Figure 1 Estados de los Threads...................................................................................................5
Figure 2 Creación Clase SincronizandoHilos.................................................................................5
Figure 3 Creación de Clase HilosVarios.........................................................................................5
Figure 4 Creación de Instancia.....................................................................................................6
Figure 5 Ejecución del Programa..................................................................................................6
Figure 6 Creación Hilo 2...............................................................................................................7
Figure 7 Implementación del método getName()........................................................................7
Figure 8 Ejecución del Programa..................................................................................................7
Figure 9 Implementación del método sleep()..............................................................................8
Figure 10 Implementación del método join()...............................................................................8
Figure 11 Ejecución del Programa................................................................................................9
Figure 12 Implementación método join().....................................................................................9
Figure 13 Ejecución del Programa..............................................................................................10

Tabla 1 Código del Programa- Sincronización de Hilos...............................................................10

1 ESTADOS DE LOS THREADS

1.1 NUEVO
Cuando un hilo está en este estado, es simplemente un objeto Thread vacío. El sistema
no ha destinado ningún recurso para él. Desde este estado solamente puede arrancarse
llamando al método start(), o detenerse definitivamente, llamando al método stop().

1.2 EJECUTABLE
La llamada al método start() creará los recursos del sistema necesarios para que el hilo
puede ejecutarse, lo incorpora a la lista de procesos disponibles para ejecución del
sistema y llama al método run() del hilo de ejecución.

Cuando el hilo se encuentra en este estado, todas las instrucciones de código que se
encuentren dentro del bloque declarado para el método run(), se ejecutarán
secuencialmente.

Thread MiThread = new MiClaseThread();

MiThread.start();

1.3 BLOQUEADO
El hilo de ejecución entra en estado Parado cuando alguien llama al método suspend(),
cuando se llama al método sleep(), cuando el hilo está bloqueado en un proceso de
entrada/salida o cuando el hilo utiliza su método wait() para esperar a que se cumpla
una determinada condición. Cuando ocurra cualquiera de las cuatro cosas anteriores, el
hilo estará Parado.

1.4 MUERTO
Un hilo que contenga a este método run(), morirá naturalmente después de que se
complete el bucle y run() concluya.

El método stop() envía un objeto ThreadDeath al hilo de ejecución que quiere detener.

Así, cuando un hilo es parado de este modo, muere asíncronamente. El hilo morirá en el
momento en que reciba ese objeto ThreadDeath.
 Figure 1 Estados de los Threads

2 EJERCICIO PRÁCTICO
 Creación de clase principal:

Figure 2 Creación Clase SincronizandoHilos


A continuación, creamos la “clase hilos varios” misma que va a heredar de thread y
sobrescribimos el método run() el cual va a tener un bucle for para imprimir por
consola un mensaje.

Figure 3 Creación
de Clase HilosVarios
 En la clase principal, creamos una instancia de la clase hilos varios para llamar a su
instancia “start()”.

Figure 4 Creación de Instancia

 Una vez que ejecutamos el proyecto, como se puede observar únicamente se va a

imprimir un mensaje 15 veces y con esto demostramos que el hilo se está ejecutando
correctamente.

Figure 5 Ejecución del Programa

 Para la creación de un nuevo hilo basta con crear una nueva instancia de la clase
hilos varios.

Figure 6 Creación Hilo 2

 Para poder distinguir que efectivamente se está ejecutando los dos hilos se utilizara
el método “getName()” que devolverá el nombre del hilo, java crea nombres
internos que van desde hilo-0 hasta hilo-n.


Una

Figure 7 Implementación del método getName()

vez ejecutado el programa podemos observar cómo se imprimen por pantalla cada
uno de los hilos creados.

Figure 8 Ejecución del Programa

 Para observar más detalladamente la ejecución de los hilos utilizamos el método
“sleep” y le asignamos el tiempo correspondiente, además es importe el uso de
excepciones mismas que se crean automáticamente.

Figure 9 Implementación del método sleep()

 Para sincronizar hilos se puede utilizar el método “join” que espera hasta que un hilo
se complete hasta su muerte, para empezar otro hilo.

Figure 10 Implementación del método join()

 Ejecutamos el programa y podemos observar como primero se ejecuta el hilo-0 y
hasta que este no termine completamente su proceso no iniciara el siguiente hilo.

Figure 11 Ejecución del Programa

 Hay que tener en consideración que el “main” como tal también representa un hilo
en ejecución es por ello que si se desea que este termine una vez se han ejecutado
todos los hilos creados tenemos que utilizar el método ya mencionado “join”.

Figure 12 Implementación método join()

 Si ejecutamos el programa efectivamente hasta que no termine con hilo-0 e hilo-1,
concluirá con su proceso y mostrara el mensaje por pantalla al finalizar, de esta
manera podemos sincronizar cada uno de los hilos creados.

Figure 13 Ejecución del Programa

3 CÓDIGO PROGRAMA
Tabla 1 Código del Programa- Sincronización de Hilos

import java.util.logging.Level;
import java.util.logging.Logger;

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author mjpacha
*/
public class SincronizandoHillos {
 /**
* @param args the command line arguments
*/
public static void main(String[] args) throws InterruptedException {
// TODO code application logic here
HilosVarios hilo1=new HilosVarios();
HilosVarios2 hilo2=new HilosVarios2(hilo1);
hilo1.start();
hilo2.start();
System.out.println("Terminadas las tareas");
}
}

class HilosVarios extends Thread {

public void run(){

for(int i=0;i<15;i++)
System.out.println("Ejecutando Hilo" + getName());
try {
Thread.sleep(500);
} catch (InterruptedException ex) {
Logger.getLogger(HilosVarios.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

4 CONCLUSIONES
 Se concluye que cuando dos o más hilos necesitan acceder de manera simultánea a
un recurso de datos compartido necesitan asegurarse de que sólo uno de ellos accede
al mismo cada vez. Java proporciona un soporte único, a nivel de lenguaje, para
dichas tareas de sincronización.

5 REFERENCIAS
[1] Tomado de: “Curso Java. Threads IV”
 Sincronización de Threads I
https://www.youtube.com/watch?v=TjcqR-twOXw