Está en la página 1de 14

Puebla, Pue a 25 de Mayo del 2015

Programación Concurrente y Paralela

Reporte Practica 1 y 2

Oscar Eduardo González Ramos

200910967
INTRODUCCION
Practica 1: Hilos en Java
Los Hilos (Threads) en Java, prácticamente son una forma de poder ejecutar
varios procesos simultáneamente en nuestros programas en Java.

Para utilizarlos tenemos que crear clases que extienden a la clase Thread, y
reescribir el método principal “run()”, el cual es el que se va a ejecutar
principalmente al iniciar un hilo, thread o nuevo proceso en java.

Hay dos modos de programar hilos (threads) en Java. Una es implementando el


interfaz Runnable y la otra es extender la clase Thread.

La implementación de la interfaz Runnable es la forma habitual para crear hilos.

La clase Thread encapsula todo el control necesario sobre los hilos de ejecución
(threads).

Metodos de la clase Thread

currentThread()

Este método devuelve el objeto thread que representa al hilo de ejecución que se
está ejecutando actualmente.

yield()

Este método hace que el intérprete cambie de contexto entre el hilo actual y el
siguiente hilo ejecutable disponible. Es una manera de asegurar que nos hilos de
menor prioridad no sufran inanición.

sleep( long )

El método sleep() provoca que el intérprete ponga al hilo en curso a dormir


durante el número de milisegundos que se indiquen en el parámetro de
invocación. Una vez transcurridos esos milisegundos, dicho hilo volverá a estar
disponible para su ejecución.
Metodos de la instancia

start()

Este método indica al intérprete de Java que cree un contexto del hilo del sistema
y comience a ejecutarlo. A continuación, el método run() de este hilo será
invocado en el nuevo contexto del hilo. Hay que tener precaución de no llamar al
método start() más de una vez sobre un hilo determinado.

run()

El método run() constituye el cuerpo de un hilo en ejecución. Este es el único


método del interfaz Runnable. Es llamado por el método start() después de que el
hilo apropiado del sistema se haya inicializado. Siempre que el método run()
devuelva el control, el hilo actual se detendrá.

stop()

Este método provoca que el hilo se detenga de manera inmediata. A menudo


constituye una manera brusca de detener un hilo, especialmente si este método se
ejecuta sobre el hilo en curso. En tal caso, la línea inmediatamente posterior a la
llamada al método stop() no llega a ejecutarse jamás, pues el contexto del hilo
muere antes de que stop() devuelva el control. Una forma más elegante de
detener un hilo es utilizar alguna variable que ocasione que el método run()
termine de manera ordenada. En realidad, nunca se debería recurrir al uso de este
método.

suspend()

El método suspend() es distinto de stop(). suspend() toma el hilo y provoca que se


detenga su ejecución sin destruir el hilo de sistema subyacente, ni el estado del
hilo anteriormente en ejecución. Si la ejecución de un hilo se suspende, puede
llamarse a resume() sobre el mismo hilo para lograr que vuelva a ejecutarse de
nuevo.

resume()

El método resume() se utiliza para revivir un hilo suspendido. No hay garantías de


que el hilo comience a ejecutarse inmediatamente, ya que puede haber un hilo de
mayor prioridad en ejecución actualmente, pero resume() ocasiona que el hilo
vuelva a ser un candidato a ser ejecutado.
setPriority( int )

El método setPriority() asigna al hilo la prioridad indicada por el valor pasado como
parámetro. Hay bastantes constantes predefinidas para la prioridad, definidas en
la clase Thread, tales como MIN_PRIORITY, NORM_PRIORITY y
MAX_PRIORITY, que toman los valores 1, 5 y 10, respectivamente. Como guía
aproximada de utilización, se puede establecer que la mayor parte de los procesos
a nivel de usuario deberían tomar una prioridad en torno a NORM_PRIORITY.

getPriority()

Este método devuelve la prioridad del hilo de ejecución en curso, que es un valor
comprendido entre uno y diez.

setName( String )

Este método permite identificar al hilo con un nombre menmónico. De esta manera
se facilita la depuración de programas multihilo. El nombre mnemónico aparecerá
en todas las líneas de trazado que se muestran cada vez que el intérprete Java
imprime excepciones no capturadas.

getName()

Este método devuelve el valor actual, de tipo cadena, asignado como nombre al
hilo en ejecución mediante setName().
DESARROLLO DE LA PRÁCTICA
a) Programa 1

b) Planteamiento:

Codificar los programas dados y observar que es lo que se genera, después de


eso comparar la diferencia entre los códigos y escribir la diferencia entre ambos.

En el código fuente 1 se implementaran dos hilos heredando de la clase Thread,


en el código fuente 2, se implementarán dos hilos con la interfaz Runnable.

c)
En el código fuente 1 se usara la herencia por medio de la clase Thread
Para ejecutar el código se usara una clase MainHiloHerencia

En el código fuente 2 se usara la clase ThreadConRunable pero para la


ejecución de los hilos se usara la interfaz Runnable.
Para ejecutar el código se usara una clase llamada MainRunable

d) Código fuente 1

public class ThreadConHerencia extends Thread


{
String palabra;

public ThreadConHerencia(String _palabra)


{
palabra = _palabra;
}

public void run()


{
for(int i=0; i<10 ; i++)
System.out.println("\n No "+i+" "+palabra);
}
}
public class MainHiloHerencia
{

public static void main(String[] args)


{
Thread a = new ThreadConHerencia("HiloUno");
Thread b = new ThreadConHerencia("HiloDos");
a.start();
b.start();

System.out.println("Hilo Uno= "+a.getName());


System.out.println("Hilo Dos= "+b.getName());
System.out.println("Fin del hilo principal");
}
}

Código fuente 2:

public class ThreadConRunable implements Runnable


{
String palabra;
public ThreadConRunable(String _palabra)
{
palabra = _palabra;
}

public void run()


{
int i;
for(i=0; i<10; i++)
System.out.println("\n No "+i+" "+palabra);
}
}
public class MainRunable
{

public static void main(String[] args)


{
ThreadConRunable a = new ThreadConRunable("Hilo 1");
ThreadConRunable b = new ThreadConRunable("Hilo 2");
Thread t1 = new Thread(a);
Thread t2 = new Thread(b);

t1.start();
t2.start();

System.out.println("\n Hilo 1= "+t1.getName());


System.out.println("\n Hilo 2= "+t2.getName());
System.out.println("\n FIN DEL HILO PRINCIPAL");
}
}
e) Pantalla de la corrida código fuente 1, usando herencia de la clase Thread

Pantalla de la corrida código fuente 2 implementando la interfaz runnable


Practica de Laboratorio 2
PLANTEAMIENTO
Codificar el código, el cual esta implementado con la clase Therad y responder las
preguntas en base a los resultados.

¿Cuáles son las prioridades de un hilo puede tener?


El ejecutarse antes que otro hilo es una propiedad que un hilo puede tener usando
el metodo setPriority(); ente los paréntesis se coloca el valor de la prioridad de ese
hilo y es conforme va a ejecutarse.

¿Como se están creando los hilos?

Se están creando a base de la clase Thread mediante el uso de la instancia,


usando el new.

Se está implementando los hilos por medio de herencia usando la clase Thread

La clases son: MainPriority(), dondé se manda a llamar el programa principal y la


clase Priority_Her ()

public class Priority_Her extends Thread

String palabra;

public Priority_Her(String _palabra)

palabra = _palabra;

public void run()

for(int i=0; i<10 ; i++)


System.out.println(palabra);

public class MainPriority

public static void main(String args[])

Priority_Her a1 = new Priority_Her("a1");

Priority_Her a2 = new Priority_Her("a2");

Thread t1 = new Thread (a1);

Thread t2 = new Thread (a2);

t1.start();

t1.setPriority(5);

System.out.println("Prioridad de t1: "+t1.getPriority());

t2.start();

System.out.println("Prioridad de t2: "+t2.getPriority());

}
CONLUSION
Una vez checado el llamado a las instancias y objetos al momentos de
implementar los hilos de las diferentes formas, en lo personal, usando la interfaz
runnable es más sencillas, claro que eso va a depender de cada programador,
para mí fue un tanto más cómodo, más fácil de comprender e implementar,
aunque no haya mucha diferencia entre las salidas de ambos programas, la
diferencia está en la implementación.

Cabe aclarar que una interfaz solamente puede contener métodos abstractos y/o
variables estáticas y finales (constantes). Las clases, por otro lado, pueden
implementar métodos y contener variables que no sean constantes.

En base a comparación resumimos que una interfaz no puede implementar


cualquier método, mientras que una clase al implementar una interfaz debe
implementar todos los métodos definidos en esa interfaz. Véase otro ejemplo para
diferenciar que la interfaz tiene la posibilidad de poder extenderse de otras
interfaces y al contrario que las clases, puede extenderse de múltiples interfaces.
La ultima cosa en cuando a comparación una interfaz no puede ser instanciada
con el operador new.

En cuanto a la practica 2 se aprendio a dar prioridad a un hilo para su ejecución


usando el metodo setPriority(), esto nos va a ayudar a darle un sentido de
sincronización a nuestro programa.
Referencias Bibliograficas

Web

http://dhw.umh.es/alex-bia/teaching/PC/material/hilos_tutorial-java/cap10-2.htm
http://panamahitek.com/multiprocesos-en-java-como-usar-hilosthreads/
http://jarroba.com/multitarea-e-hilos-en-java-con-ejemplos-thread-runnable/

También podría gustarte