PROYECTO FINAL
PROYECTO FINALTEMA: HILOS Y MULTIHILOS14/07/2015
INDICEProyecto final de Hilos y Multihilos Introduccin
---------------------------------------------------------------------------21)
Hilos y multihilos
--------------------------------------------------------------3Qu
son hilos y multihilos?
-------------------------------------------------3Mtodos
thread-------------------------------------------------------------
4-5Ejercicio
-------------------------------------------------------------------------5
Sin Hilos Clase Cajera.java
-------------------------------------------------------6 Clase
Cliente.java------------------------------------------------------
7 Clase Ejecutar.java
-----------------------------------------------------7 Resultados
---------------------------------------------------------------------8Con
Hilos Clase
CajeraThread.java-----------------------------------------------9
Clase EjecutarThread.java
--------------------------------------------10 Resultados
--------------------------------------------------------------------10Conclusiones
---------------------------------------------------------------------------12
INTRODUCCIONEn 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 MULTIHILOSQu 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:
CONCLUCIONESAl 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.
