El documento presenta 4 programas escritos en Java que demuestran el uso de hilos concurrentes y paralelos. El primer programa crea una ventana gráfica simple que muestra la palabra "HOLA". Los programas 2 y 3 imprimen cadenas de texto usando hilos con herencia y la interfaz Runnable. El programa 4 establece prioridades y atributos como "daemon" en hilos creados con herencia e interfaz.

1. BENEMERITA UNIVERSIDAD
AUTONOMA DE PUEBLA
FACULTAD DE CIENCIAS
DE LA COMPUTACION
PROGRAMACION CONCURRENTE Y PARALELA
MONITORES

2. LEZAMA SANCHEZ ANA LAURA
VALENCIA TOXQUI HUMBERTO
INTRODUCCION
El siguiente reporte describe los programas presentados el 20 de enero de
2012
DESARROLLO
1.-Programa que imprime la palabra HOLA pero en una ventana grafica usando
el paquete que importa los componentes graficos import javax.swing.*; y
declarando la clase hola que implementa una ventana principal sencilla que
contiene una etiqueta.
Código:
import javax.swing.*;
//seccion creacion de la clase ventanal
public class hola extends JFrame
{
private JLabel label1;
public hola(){
setLayout(null);
label1=new JLabel("HOLA");
label1.setBounds(100,100,300,30);

3. add(label1);
}
public static void main(String args[])
{
//area de definicion de propiedades del objeto
hola hola1=new hola();
hola1.setBounds(10,10,300,300);
hola1.setVisible(true);
}
}
Pantalla de la corrida:
***********************************************************

4. 2.-El programa a) imprime el grafo del ejercicio elaborado en clase, con las
condiciones de Bernstein, este primero es la clase Grafohilo con herencia y
usando 5 hilos, uno por cada nodo del grafo y la instrucción sleep,el programa
b) imprime lo mismo, usa el mismo número de hilos y sleep, pero usando
Runnable(interfaz)
Gráficamente el grafo quedo de la siguiente forma:
S1 S3
S2
S4
S5
a)Codigo(herencia)
//con herencia
class Grafohilo extends Thread
{
String palabra;
public int duerme;

5. public Grafohilo(String _palabra,int mili)
{
palabra=_palabra;
duerme=mili;
}
public void run()
{
try
{
Thread.sleep(duerme);
System.out.println(palabra);
}
catch(InterruptedException e){}
}
public static void main(String args[])
{
Grafohilo s1=new Grafohilo("hilo1",1000);
Grafohilo s2=new Grafohilo("hilo2",2000);
Grafohilo s3=new Grafohilo("hilo3",1000);
Grafohilo s4=new Grafohilo("hilo4",3000);
Grafohilo s5=new Grafohilo("hilo5",4000);
Thread t1=new Thread(s1);
Thread t2=new Thread(s2);
Thread t3=new Thread(s3);
Thread t4=new Thread(s4);

6. Thread t5=new Thread(s5);
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
a)salida
**********************************************************
b)código(interfaz)
//CON INTERFAZ
public class Grafohilo implements Runnable
{
String palabra;
public int duerme;
public Grafohilo(String _palabra,int mili)

7. {
palabra=_palabra;
duerme=mili;
}
public void run()
{
try
{
Thread.sleep(duerme);
System.out.println(palabra);
}
catch(InterruptedException e){}
}
public static void main(String args[])
{
Grafohilo s1=new Grafohilo("hilo1",1000);
Grafohilo s2=new Grafohilo("hilo2",2000);
Grafohilo s3=new Grafohilo("hilo3",1000);
Grafohilo s4=new Grafohilo("hilo4",3000);
Grafohilo s5=new Grafohilo("hilo5",4000);
Thread t1=new Thread(s1);
Thread t2=new Thread(s2);
Thread t3=new Thread(s3);
Thread t4=new Thread(s4);
Thread t5=new Thread(s5);

8. t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
b)Salida
******************************************************
3.-Los siguientes programas:
a) Empezando a usar hilos con herencia :programa que lanza 2 hilos y
hace que se imprima 10 veces la palabra hiloUno(siendo este el primer hilo) y
10 veces la palabra hiloDos(siendo este el segundo hilo)
código
class ThreadConHerencia extends Thread
{
String palabra;
public ThreadConHerencia (String _palabra)

9. {
palabra =_palabra;
}
public void run()
{
for (int i=0; i<10; i++)
System.out.print (palabra);
}
public static void main(String[] args)
{
Thread a = new ThreadConHerencia ("hiloUno");
Thread b = new ThreadConHerencia ("hiloDos");
a.start();
b.start();
System.out.println ("Fin del hilo principal");
}
}
Salida
***************************************************************
b) Empezando a usar hilos con interfaz : programa con Runnable que lanza 2
hilos y hace que se imprima 10 veces la palabra hiloUno(siendo este el primer
hilo) y 10 veces la palabra hiloDos(siendo este el segundo hilo).

10. Código:
public class ThreadConRunnable implements Runnable
{
String palabra;
public ThreadConRunnable (String _palabra)
{
palabra = _palabra;
}
public void run()
{
for (int i = 0;i<10;i++)
{
System.out.println (palabra);
}
}
public static void main(String[] args)
{
ThreadConRunnable a = new ThreadConRunnable
("hiloUno");
ThreadConRunnable b = new ThreadConRunnable
("hiloDos");
Thread t1 = new Thread (a);
Thread t2 = new Thread (b);

11. t1.start();
t2.start();
System.out.println ("Fin del hilo principal");
}
}
Salida:
*********************************************************
4.-Prioridad con herencia e interfaz: programa que arroja que hilo tiene la
prioridad mas alta, media o baja, el nombre del hilo, si es hilo demonio y si
determinado hilo esta vivo
a) con herencia
código
public class A extends Thread
{
String palabra;

12. public A (String _palabra)
{
palabra = _palabra;
}
public void run ()
{
for (int i=0;i<100;i++)
System.out.println (palabra);
}
public static void main (String args[])
{
/*A a1 = new A("a1");
A a2 = new A("a2");
A a3 = new A("a3");
A a4 = new A("a4");
A a5 = new A("a5");*/
Thread t1 = new Thread ("a1");
Thread t2 = new Thread ("a2");
Thread t3 = new Thread ("a3");
Thread t4 = new Thread ("a4");
Thread t5 = new Thread ("a5");
t1.setPriority(10);
t2.setPriority(5);

13. t3.setPriority(1);
t4.setDaemon(true);
t5.setName("HILO");
System.out.println ("Prioridad de t1:
"+t1.getPriority());
System.out.println ("Prioridad de t2:
"+t2.getPriority());
System.out.println ("Prioridad de t3:
"+t3.getPriority());
System.out.println ("¿El hilo t4 es un hilo demonio?
"+t4.isDaemon());
System.out.println ("Nombre del hilo
t5:"+t5.getName());
System.out.println ("¿El hilo t4 esta
vivo?:"+t4.isAlive());
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
Salida

14. ***************************************************************
b)prioridad con interfaz
código
//con interfaz
public class A implements Runnable
{
String palabra;
public A (String _palabra)
{
palabra = _palabra;
}
public void run ()
{
for (int i=0;i<100;i++)
System.out.println (palabra);
}
public static void main (String args[])
{
A a1 = new A("a1");
A a2 = new A("a2");

15. A a3 = new A("a3");
A a4 = new A("a4");
A a5 = new A("a5");
Thread t1 = new Thread (a1);
Thread t2 = new Thread (a2);
Thread t3 = new Thread (a3);
Thread t4 = new Thread (a4);
Thread t5 = new Thread (a5);
t1.setPriority(10);
t2.setPriority(5);
t3.setPriority(1);
t4.setDaemon(true);
t5.setName("HILO");
System.out.println ("Prioridad de t1:
"+t1.getPriority());
System.out.println ("Prioridad de t2:
"+t2.getPriority());
System.out.println ("Prioridad de t3:
"+t3.getPriority());
System.out.println ("¿El hilo t4 es un hilo demonio?
"+t4.isDaemon());
System.out.println ("Nombre del hilo
t5:"+t5.getName());
System.out.println ("¿El hilo t4 esta
vivo?:"+t4.isAlive());

16. t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
Salida
.
.

17. .

18. Conclusión
Los anteriores programas me ayudaron a recordar la herencia en java, aprendí
a usar Runnable, aunque en el programa de prioridad me quedo duda ya que
en la parte de herencia el JCreator no me permitió dejar de crear objetos como
en interfaz.
Realizando el resumen quedo un poco más claro, el concepto de hilo y como
usarlo, me ayudo a aclarar conceptos del propio lenguaje tales como manejar
.get, .set, el uso de los vectores, como crear las ventanas con JFrame y los
applets.
Espero con los siguientes laboratorios aprender más sobre la materia y
terminar de comprender los conceptos aquí tratados.
Bibliografía
http://www.cs.buap.mx/~mceron/principal_con.html