01

qwertyuiopasdfghjklzxcvb
nmqwertyuiopasdfghjklzx
cvbnmqwertyuiopasdfghjk
PROYECTO FINAL
lzxcvbnmqwertyuiopasdfg
TEMA: HILOS Y MULTIHILOS
hjklzxcvbnmqwertyuiopas
dfghjklzxcvbnmqwertyuio
pasdfghjklzxcvbnmqwerty
uiopasdfghjklzxcvbnmqwe
rtyuiopasdfghjklzxcvbnmq
wertyuiopasdfghjklzxcvbn
mqwertyuiopasdfghjklzxc
vbnmqwertyuiopasdfghjkl
zxcvbnmqwertyuiopasdfg
hjklzxcvbnmqwertyuiopas
dfghjklzxcvbnmqwertyuio
pasdfghjklzxcvbnmqwerty
uiopasdfghjklzxcvbnmqwe
CURSO: PROGRAMACION II

DOCENTE: ING. ALCIDES BERNARDO

TELLO

INTEGRANTES: EVARISTO COZ, BEATRIZ

M.

MEZA ALONSO,

INDICE
Proyecto final de Hilos y Multihilos
Introduccin ---------------------------------------------------------------------------2
1) Hilos y multihilos --------------------------------------------------------------3
Qu son hilos y multihilos?
-------------------------------------------------3
Mtodos thread------------------------------------------------------------- 4-5
Ejercicio -------------------------------------------------------------------------5
Sin Hilos
Clase Cajera.java -------------------------------------------------------6
Clase Cliente.java------------------------------------------------------ 7
Clase Ejecutar.java -----------------------------------------------------7
Resultados ---------------------------------------------------------------------8
Con Hilos
Clase CajeraThread.java-----------------------------------------------9
Clase EjecutarThread.java
--------------------------------------------10
Resultados
--------------------------------------------------------------------10
Conclusiones ---------------------------------------------------------------------------12

INTRODUCCION
En el presente trabajo hablaremos sobre hilos y multihilos ya que
estos nos permiten ejecutar varios procesos y as ejecutndose en
menos tiempo, haremos un ejercicio usando hilos como tambin sin
hilos y nos daremos cuenta cual es ms eficiente .

HILOS Y MULTIHILOS
Qu son hilos y multihilos?
En esencia los hilos y multihilos nos permiten ejecutar varios procesos
a la vez; es decir, de forma concurrente y por tanto eso nos permite
hacer programas que se ejecuten en menor tiempo y sean ms
eficientes.

Si en vez de hacerlo de forma secuencial, lo hicisemos con 4 hilos, el

programa tardara en ejecutarse solo 20 segundos, es decir el tiempo
que tardara en ejecutarse el proceso ms largo.

Utilizar la multitarea debemos de usar la clase Thread (es decir que la

clase que implementemos debe heredar de la clase Thread) y la clase
Thread implementa la Interface Runnable.

METODOS THREAD:

El mtodo star() y run(): Para poner en marcha un nuevo

thread (hilo) se debe llamar al mtodo star(), heredado de la

super-clase Thread, que se encarga de llamar a run(). El mtodo
run() contiene el cdigo a ser ejecutado en otro thread,
mientras que el mtodo star() es el que crea al mtodo Thread.
El mtodo join(): un Thread (hilo) necesita esperar que otro
termine pude usar el mtodo join(). Por qu se llama as? Crear
un proceso es como una bifurcacin (), se abre dos caminos,
que en uno espere a otro es lo contrario, una unificacin ().
El mtodo yield(): Tiene la funcin de hacer que un hilo que se
est ejecutando de regreso al estado en listo para ejecutar
para as permitir que otros hilos con la misma importancia
puedan ejecutarse. Sin embargo el funcionamiento de este
mtodo no est garantizado, puede que despus que se
establezca un hilo por medio del mtodo yield() a su estado de
listo para ejecutar este vuelva a ser elegido para ejecutarse,

ya que el mtodo yield() nunca causara que un hilo pase a

estado de espera/bloqueado/dormido.
El mtodo sleep (): Simplemente le dice al Thread () que
duerma durante los milisegundos especficos. Se debera utilizar
este mtodo cuando se pretenda retrasar la ejecucin del
Thread. Sleep () no consume recursos, mientras los otros Threas
siguen funcionando con normalidad.
El mtodo currentthread (): Para saber que hilos se encuentra
en ejecucin en un momento determinado, existe el mtodo
esttico Thread.currentThread(). Thread.currentThread
().getName () te devuelve un valor de tipo cadena con el
nombre del hilo en ejecucin.
El mtodo suspend ()): puede resultar muy til suspender la
ejecucin de un Thread sin marcar un lmite de tiempo. No se
trata de terminar el Thread, sino desactivarla.
El mtodo resume(): Ya que el mtodo suspend() no detiene la
ejecucin permanente, el Thread queda suspendido
indefinidamente y para volver a activarlo de nuevo
necesitamos realizar una invocacin del mtodo resume()
objThread.resume();
El mtodo stop (): este mtodo da una muerte al Thread (hilo).

EJERCICIO:
Vamos a simular el proceso de cobro de un supermercado; es decir,
unos clientes van con un carro lleno de productos y una cajera les
cobra los productos, pasndolos uno a uno por el escner de la caja
registradora. En este caso la cajera debe de procesar la compra
cliente a cliente, es decir que primero le cobra al cliente 1, luego al
cliente 2 y as sucesivamente. Para ello vamos a definir una clase
Cajera y una clase Cliente el cual tendr un array de enteros
que representaran los productos que ha comprado y el tiempo que la
cajera tardar en pasar el producto por el escner; es decir, que si
tenemos un array con [1,3,5] significar que el cliente ha comprado 3
productos y que la cajera tardara en procesar el producto 1 1
segundo, el producto 2 3 segundos y el producto 3 en 5 segundos,
con lo cual tardara en cobrar al cliente toda su compra 9 segundos.
1) ANALIZAMOS EL EJERCICIO SIN HILOS

CLASE Cajera.java

CLASE Cliente.java

Si ejecutsemos este programa propuesto con dos Clientes y con un

solo proceso (que es lo que se suele hacer normalmente), se
procesara primero la compra del Cliente 1 y despus la del Cliente 2,
con lo cual se tardar el tiempo del Cliente 1 + Cliente 2.
CLASE Ejecutar.java

El cdigo ser el siguiente:

Como
vemos se
procesa

primero la
compra del cliente 1 y despus la compra del cliente 2 tardando en
procesar ambas compras un tiempo de 26 segundos.
2) ANALIZAMOS EL EJERCICIO USANDO HILOS (THREAD)

CLASE cajeraThread.java

CLASE EjecutarThread.java

Ahora vamos a ver cual sera el resultado de esta ejecucin y vamos a

comprobar como efectivamente el programa se ejecuta de forma
paralela y tarda solo 15 segundos en terminar su ejecucin:

En este ejemplo vemos como el efecto es como si dos cajeras

procesasen la compra de los clientes de forma paralela sin que el
resultado de la aplicacin sufra ninguna variacin en su resultado
final, que es el de procesar todas las compras de los clientes de forma
independiente. De forma grfica vemos que el programa ha realizado
lo siguiente en dos hilos distintos:

CONCLUCIONES
Al culminar este trabajo llegamos a la concclucion de que el uso hilos es
muy util y se ha de aplicar para hacer las aplicaciones ms eficientes y que
den mejor rendimiento.