AÑO DE LAS CUMBRES MUNDIALES EN EL PERU"

ESCUELA DE INGENIERIA DE SISTEMAS

UCV – PIURA

INTEGRANTES :

• Huanca Cruz Joan Eddy

• Mendoza Yovera Lucia Carolina
• Balcazar Rivas Renato
• Hernández Abramonte Wilfredo

DOCENTE :
• Ing. CIP Aldo Pereda Castillo

CURSO :

• Programación Orientada a Objetos

CICLO :
• IV
ESCUELA :

• Ing. Sistemas

2008

1
 INTRODUCCION

El tema que trataremos en el presente trabajo, es uno de los más

interesantes que puede tener un lenguaje de programación (java), muchos al
iniciarnos en este muy bonito e interesante mundo de la programación, solo
realizábamos programas (c, c++, etc.), el cual trataba de darle una orden y
este cumpliese con un cometido, no dándonos la oportunidad de realizar otra
cosa si es que por ejemplo: esperaba que ingrese algún dato.
Este problema es superado con java, que nos brinda la oportunidad de
realizar distintas acciones, en tiempo compartido, es decir dar la sensación
de realizar infinidad de cosas al mismo tiempo, pero que en realidad
internamente es un simple repartimiento de memoria.

Todos tenemos siempre aunque en forma indirecta el contacto con este

mecanismo: cuando hacemos el uso del programa Microsoft Word vemos que
este programa realiza tareas de forma “Simultanea”, por ejemplo, podemos
estar escribiendo y a la vez el programa está revisando los errores
ortográficos para corregirlos.

O también el mismo sistema operativo por que puede estar copiando

archivos, a la vez mostrando la hora, navegando por internet, etc.

Sin más preámbulos empecemos con todo lo que concierne a los Threads, un
tema que a mi parecer es la matriz de la programación orientada a objetos.

2
 INDICE

I. QUE ES UNTHREAD……………………………………………………………………………………… 3
¿PARA QUE SE UTILIZAN ?
1. TIPOS DE THREAD
2. CONTROL BASICO DE UN THREAD
II. CLASES RELACIONADAS CON LOS HILOS……………………………………………5
1. LA CLASE THREADS
2. Runnable
3. ThreadDeath
4. TreadGroup
5. Object
III. CICLO DE VIDA DE UN THREAD ………………………………………………………………8

IV. PRIORIDADES ……………………………………………………………………………………………….8

V. CONTROL DE UN HILO………………………………………………………………………………..12
1. Arranque de un hilo
2. Manipulación de un hilo
3. Suspensión de un Hilo
4. Parada de un Hilo
• stop ()
• isAlive ()
VI. AGRUPAMIENTO DE HILOS……………………………………………………………………...13
1. Grupo de hilos por defecto
2. Grupo de hilos de forma explicita
VII. LA CLASE ThreadGroup …………………………………………………………………………………15

VIII. THREAD DAEMON………………………………………………………………………………………….15

IX . SINCRONIZACION……………………………………………………………………………………………..16

1. Uso de synchronized.

2. Comunicación entre threads

3. Monitores

IX. CONCLUSIONES………………………………………………………………………………………………….18

3
I. QUE ES UN THREAD:

También conocido en java como hilos o subproceso.

Los threads o hilos de ejecución son segmentos de código de un programa que

se ejecutan secuencialmente de modo independiente de otras partes del
programa.Un proceso puede estar constituido por uno o mas threads.

Un thread es un contexto de ejecución, proceso ligero o tarea donde hay un

flujo secuencial de control y que utiliza los recursos disponibles para un
programa.

La Máquina Virtual Java (JVM) es un sistema multihilo. Es decir, es capaz de

ejecutar varios hilos de ejecución simultáneamente. La JVM gestiona todos los
detalles, asignación de tiempos de ejecución, prioridades, etc.

De forma similar a como gestiona un Sistema Operativo múltiples procesos. La

diferencia básica entre un proceso de Sistema Operativo y un Thread Java es
que los hilos corren dentro de la JVM, que es un proceso del Sistema Operativo
y por tanto comparten todos los recursos, incluida la memoria y las variables y
objetos allí definidos.
A este tipo de procesos donde se comparte los recursos se les llama a veces
procesos ligeros.

Desde el punto de vista de las aplicaciones los hilos son útiles porque permiten
que el flujo del programa sea divido en dos o más partes, cada una ocupándose
de alguna tarea de forma independiente. Por ejemplo un hilo puede encargarse
de la comunicación con el usuario, mientras que otros actúan en segundo plano,
realizando la transmisión de un fichero,
Accediendo a recursos del sistema (cargar sonidos, leer ficheros...), etc. De
hecho, todos los programas con interfaz gráfico (AWT o Swing) son multihilo
porque los eventos y las rutinas de dibujado de las ventanas corren en un hilo
distinto al principal.

¿PARA QUE SE UTILIZAN ?

Los threads se utilizan para aislar y coordinar tareas.

Sin el uso de threads hay aplicaciones que son casi imposibles de programar:
• Las que tienen tiempos de espera importantes entre etapas
• Las que consumen muchos recursos de CPU e impiden que el
procesador atienda simultáneamente otros eventos o peticiones
del usuario

4
1. TIPOS DE THREAD
Tipos de threads que pueden aparecer en una aplicación:

• Threads completamente independientes, que realizan tareas no

relacionadas. Éste es el caso más sencillo y no requiere ninguna
programación especial.

• Threads que trabajan en una misma tarea, pero sin interferir ni

intercambiar relación entre ellos. Por ejemplo, threads que colaboran
en el producto de dos matrices ocupándose cada una de ellas de
calcular ciertas filas de la matriz producto.

• Threads que utilizan recursos de modo mutuamente exclusivo,

aunque sin tener que coordinar sus actividades. Por ejemplo, threads
que actualizan o leen registros de una base de datos y que no pueden
actuar simultáneamente.

• Threads que deben de coordinar sus actividades, de modo que una

de ellas no puede empezar o continuar hasta que la otra haya realizado
su tarea. Los ejemplos más típicos son los de tipo productor-
consumidor, en el que este último tiene que esperar para realizar su
función a que el productor le haya preparado los datos y le avise de esa
circunstancia.

2. CONTROL BASICO DE UN THREAD

• Finalización del la ejecución de un thread.

o Cuando un thread acaba su ejecución y es finalizado, no puede

volver a ser ejecutado.

o Podemos detener un thread utilizando un flag que utiliza un

método run que debe terminar la ejecución.
• r.stopRunning() // r instancia de una clase que implementa
runnable

• Verificación del estado thread isAlived()

o boolean isAlived (). Devuelve true si el thread ha sido
inicializado con start y no ha terminado el ciclo de ejecución.
• Bloqueo de threads.
o sleep(). Permite detener un thread durante un determinado
tiempo

5
 o join(). Bloquea el thread actual, hasta que el thead sobre el
cual ha sido ejecutado el join termina.

II. CLASES RELACIONADAS CON LOS HILOS:

El lenguaje de programación Java proporciona soporte para hilos a través de

una simple interfase.
Y un conjunto de clases. La interfase de Java y las clases que incluyen
funcionalidades sobre
Hilos son las siguientes:

• Thread
• Runnable
• ThreadDeath
• ThreadGroup
• Object

Todas estas clases son parte del paquete Java.lang.

1. la clase thread

La clase Thread es la clase responsable de producir hilos funcionales para otras

clases.
La forma más directa para añadir la funcionalidad a un hilo es extender la clase
Thread, y redefinir el método run (). Este método es invocado cuando se inicia
el hilo (mediante una llamada a método start () de la clase Thread). El hilo se
inicia con la llamada al método run () y termina cuando termina éste.
Pero esta forma nos provoca algunas limitaciones, como bien sabemos JAVA no
admite la herencia múltiple, Así que si queremos heredar de otra clase ya no lo
podemos hacer por que ya estamos heredando de la clase thread; pero
felizmente existe una solución a este inconveniente, esto se realiza
implementando lo que llamamos como interfaz, debemos implementar la
interfaz runnable que veremos más a delante.
El ejemplo ilustra estas ideas:

public class ThreadEjemplo extends Thread {

public ThreadEjemplo (String str) {

super (str);

6
public void run() {

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

System.out.println (i + " " + getName ());

System.out.println ("Termina thread” + getName ());

Public static void main (String [] args) {

new ThreadEjemplo ("Pepe").start();

new ThreadEjemplo("Juan").start();

System.out.println("Termina thread main");

2. Runnable

Java no soporta herencia múltiple de forma directa, es decir, no se puede

derivar una clase de varias clases padre. Esto nos plantea la duda sobre cómo
podemos añadir la funcionalidad de Hilo a una clase que deriva de otra clase,
siendo ésta distinta de Thread. Para lograr esto se utiliza la interfaz Runnable.
La interfaz Runnable proporciona la capacidad de añadir la funcionalidad de un
hilo a una clase simplemente implementando la interfaz, en lugar de derivándola
de la clase Thread.
Las clases que implementan la interfaz Runnable proporcionan un método run
que es ejecutado por un objeto hilo asociado que es creado aparte. Esta es una
herramienta muy útil y a menudo es la única salida que tenemos para incorporar
multihilo dentro de las clases. Esta cuestión será tratada más ampliamente en
el apartado de Creación de hilos.
Aunque es un único método el que se define en esta interfaz

3. ThreadDeath

La clase de error ThreadDeath proporciona un mecanismo que permite hacer

limpieza después de que un hilo haya sido finalizado de forma asíncrona. Se
llama a ThreadDeath una clase error porque deriva de la clase Error, la cual
proporciona medios para manejar y notificar errores. Cuando el método stop de
un hilo es invocado, una instancia de ThreadDeath es lanzada por el moribundo
hilo como un error. Sólo se debe recoger el objeto ThreadDeath si se necesita
para realiza una limpieza específica a la terminación asíncrona, lo cual es una

7
situación bastante inusual. Si se recoge el objeto, debe ser relanzado para que
el hilo realmente muera.

4. ThreadGroup

La clase ThreadGroup se utiliza para manejar un grupo de hilos de modo

conjunto. Esto nos proporciona un medio para controlar de modo eficiente la
ejecución de una serie de hilos. Por ejemplo la clase ThreadGroup nos
proporciona métodos stop, suspend y resume para controlar la ejecución de
todos los hilos pertenecientes al grupo. Los grupos de hilos también
Pueden contener otros grupos de hilos permitiendo una jerarquía anidada de
hilos. Los hilos individuales tienen acceso al grupo pero no al padre del grupo.

5. Object

Aunque, estrictamente hablando, no es una clase de apoyo a los hilos, la clase

objeto proporciona unos cuantos métodos cruciales dentro de la arquitectura
multihilo de Java. Estos métodos son wait, notify y notifyAll.

El método wait hace que el hilo de ejecución espere en estado dormido hasta
que se le notifique que continúe. Del mismo modo, el método
notify informa a un hilo en espera de que continúe con su ejecución. El método
notifyAll es similar a notify excepto que se aplica a todos los hilos en espera.
Estos tres métodos solo pueden ser llamados desde un método o bloque
sincronizado (o bloque de sincronización).

Normalmente estos métodos se utilizan cuando hay ejecución multihilo, es

decir, cuando un método espera a que otro método termine de hacer algo antes
de poder continuar. El primer hilo espera hasta que otro hilo le notifique que
puede continuar. La clase objeto está en la parte superior de la jerarquía de
Java, lo cual significa que es el padre de todas las clases.

En otras palabras, cada clase Java hereda la funcionalidad proporcionada por la

clase objeto, incluyendo los métodos wait, notify y notifyAll.

8
III. CICLO DE VIDA DE UN THREAD:

El inicio de este ciclo empieza con la instancia de la clase thread, es decir se

crea un nuevo thread que está en su estado inicial; en este estado es solo un
objeto más.
No existe el thread en ejecución. El único método que puede invocarse sobre él
es el método Start().

Al invocarse éste sobre el hilo el sistema crea los recursos necesarios, lo

planifica (le asigna prioridad) y luego llama al método run(). En este momento el
hilo está corriendo se encuentra en estado runnable (ejecutable).

Si el método run() invoca internamente el método sleep() o wait() o el hilo

tiene que esperar por una operación de entrada/salida, entonces el hilo pasa al
estado no runnable (no ejecutable) hasta que la condición de espera finalice.
Durante este tiempo el sistema puede ceder control a otros hilos activos.

Por último cuando el método run finaliza el hilo termina y pasa a la situación
Dead (Muerto).

IV.PRIORIDADES:

Los programas en java pueden utilizar el subprocesamiento múltiple. Todo

subproceso o hilo en java tiene una prioridad en el rango entre Thread.
MIN_PRIORITY (una constante de 1) y Thread.MAX_PRIORITY (una
constante de 10). De manera informal, los hilos con mayor prioridad son mas
importantes para un programa, y se les debe asignar tiempo en el procesador
antes que a los hilos de menor prioridad. Sin embargo las prioridades de los

9
hilos no pueden garantizar el orden en que se ejecutarán. De manera
predeterminada, a cada hilo se le asigna la prioridad
Thread.NORM_PRIORITY (una constante de 5).

Cuando hay varios hilos en condiciones de ser ejecutados (estado runnable), la

máquina virtual elige el hilo que tiene una prioridad más alta, que se ejecutará
hasta que:

• Un hilo con una prioridad más alta esté en condiciones de ser

ejecutado (runnable)

• El hilo termina (termina su método run)

• Se detiene voluntariamente

• Alguna condición hace que el hilo no sea ejecutable (runnable), como

una operación de entrada/salida o, si el sistema operativo tiene
planificación por división de tiempos (time slicing), cuando expira el
tiempo asignado.

Si dos o más hilos están listos para ejecutarse y tienen la misma prioridad, la
máquina virtual va cediendo control de forma cíclica (round-robin).
El hecho de que un hilo con una prioridad más alta interrumpa a otro se
denomina se denomina planificación apropiativa (preemptive scheduling).
Cuando un hilo entra en ejecución y no cede voluntariamente el control para que
puedan ejecutarse otros hilos, se dice que es un hilo egoísta (selfish thread).

Algunos Sistemas Operativos, como Windows, combaten estas actitudes con

una estrategia de planificación por división de tiempos (time-slicing), que opera
con hilos de igual prioridad que compiten por la Sistemas Distribuidos. En estas
condiciones el Sistema Operativo asigna tiempos a cada hilo y va cediendo el
control consecutivamente a todos los que compiten por el control de la CPU,
impidiendo que uno de ellos se apropie del sistema durante un intervalo de
tiempo prolongado.
Recordar que este mecanismo lo da el sistema operativo, no JAVA.

Métodos para el manejo de prioridades:

10
 • SetPriority; Ajusta la prioridad de un hilo o thread, el cual acepta un
argumento int en el rango de 1-10.

• GetPriority; Devuelve la prioridad del subproceso o hilo.

• Yield; da a otros subprocesos o hilos la oportunidad para ejecutarse.

OTRA FORMA DE CREAR HILOS

Implementándolo con la interfase Runnable. Veamos el siguiente ejemplo:

public class MiThread implements Runnable {

Thread t;
public void run() {
// Ejecución del thread una vez creado
}
}
En este caso necesitamos crear una instancia de Thread antes de que el
sistema pueda ejecutar el proceso como un hilo. Además, el método abstracto
run que está definido en la interfaz Runnable tiene que implementarse en la
nueva clase creada.

La diferencia entre ambos métodos de creación de hilos en Java radica en la

flexibilidad con que cuenta el programador, que es mayor en el caso de la
utilización de la interfaz Runnable.

Sobre la base del ejemplo anterior, se podría extender la clase MiThread a

continuación, si fuese necesario. La mayoría de las clases creadas que necesiten
ejecutarse como un hilo implementarán la interfaz Runnable, ya que así queda
cubierta la posibilidad de que sean extendidas por otras clases.

Por otro lado, es un error pensar que la interfaz Runnable está realizando
alguna tarea mientras un hilo de alguna clase que la implemente se está
ejecutando. Es una interfaz, y como tal, sólo contiene funciones abstractas
(concretamente una única, run), proporcionando tan solo una idea de diseño, de
infraestructura, de la clase Thread, pero ninguna funcionalidad. Su declaración
en Java tiene el siguiente aspecto:

package Java.lang;

11
public interfaz Runnable {
public abstract void run() ;
}

Comentados los aspectos más importantes de la interfaz Runnable, veamos

ahora la definición de la clase Thread, de la cual podemos deducir lo que
realmente se está haciendo:

public class Thread implements Runnable {

...
public void run() {
if( tarea != null )
tarea.run () ;
}
...}
Se deduce, por tanto, que la propia clase Thread de Java también implementa
la interfaz Runnable. Observamos que en el método run de Thread se
comprueba si la clase con que se está trabajando en ese momento (tarea), que
es la clase que se pretende ejecutar como hilo, es o no nula. En caso de no ser
nula, se invoca al método run propio de dicha clase.

 Una vez de haber visto las dos maneras de crear un hilo , sale a la luz la
interrogante de cual es mejor usar , a continuación veamos un poco de los
beneficios de cada uno :

o Implementar la interfaz Runnable:

• Mejor diseño orientado a objetos. La clase thread solo

deberá ser extendida cuando se pretenda modificar o
extender el comportamiento de dicho modelo de ejecución.
• Herencia simple. Debido a la tecnología de Java no es posible
extender una clase cuando ésta ya ha sido extendida a la
clase thread

o Extender la clase Thread:

• Código más simple. En el método run la referencia this
apunta a la instancia del thread actual

V. CONTROL DE UN HILO:

12
 1. Arranque de un hilo

En el contexto de las aplicaciones, sabemos que es main la primera función que

se invoca tras arrancar, y por tanto, lógicamente, es el lugar más apropiado
para crear y arrancar otros hilos.
La línea de código:

TestTh t1 = new TestTh (“Thread 1",(int) (Math.random ()*2000));

siendo TestTh una subclase de la clase Thread (o una clase que implemente la
interfaz Runnable) crea un nuevo hilo. Los dos argumentos pasados, sin mayor
relevancia, satisfarán el prototipo del constructor de la clase y se utilizarán
para la inicialización del objeto.

Al tener control directo sobre los hilos, tenemos que arrancarlos

explícitamente. Como ya se comentó anteriormente, es la función miembro
start la que nos permite hacerlo. En nuestro ejemplo sería:

start (); en realidad es un método oculto en el hilo que llama al método run.

2. Manipulación de un hilo

Si todo fue bien en la creación del objeto TestTh (t1), éste debería contener
un hilo, una traza de ejecución válida, que controlaremos en el método run del
objeto.

El cuerpo de esta función miembro viene a ser el cuerpo de un programa como

ya los conocemos. Digamos que es la rutina main a nivel de hilo. Todo lo que
queremos que haga el hilo debe estar dentro del método run. Cuando finalice
run, finalizará también el hilo que lo ejecutaba.
3. Suspensión de un Hilo

La función miembro suspend de la clase Thread permite tener un control sobre

el hilo de modo que podamos desactivarlo, detener su actividad durante un
intervalo de tiempo indeterminado, a diferencia del uso de la llamada al sistema
sleep, que simplemente lleva al hilo a un estado de “dormido”, y siempre durante
un número de milisegundos concreto.
Este método puede resultar útil si, construyendo un applet con un hilo de
animación, queremos permitir al usuario detener (que no finalizar) la animación,
hasta que éste decida reanudarla.

13
El hilo es suspendido indefinidamente y para volver a activarlo de nuevo
necesitamos realizar una invocación a la función miembro resume.

4. Parada de un Hilo

Ya conocemos los métodos de control de hilos que nos permiten arrancarlos,

suspenderlos y reanudarlos. El último elemento de control que se necesita
sobre hilos es el método stop, utilizado para terminar la ejecución de un hilo de
forma permanente:

• stop ();

Señalar que esta llamada no destruye el hilo, sino que detiene su ejecución, y
ésta no puede reanudarse con el método start. Cuando se designen las variables
que se usan en el hilo, el objeto hilo (creado con new) quedará marcado para
eliminarlo y el garbage collector (recolector de basura de Java) se encargará
de liberar la memoria que utilizaba.

Tiene sentido su utilidad, por ejemplo, en aplicaciones complejas que necesiten

un control sobre cada uno de los hilos que se lancen.
Por último, un método de control de hilos que nos permite comprobar si una
instancia está viva (el hilo se ha arrancado y aún no se ha detenido) o no (bien
no se arrancó; bien ya finalizó).

Estamos hablando de la función miembro isAlive.

• isAlive ();

Devolverá true en caso de que el hilo esté vivo, es decir, ya se haya llamado a
su método run y no haya sido parado con un stop ni haya terminado el método
run en su ejecución. En otro caso, lógicamente, devolverá false.

VI. AGRUPAMIENTO DE HILOS:

Todo hilo de Java es un miembro de un grupo de hilos. Los grupos de hilos

proporcionan un mecanismo de reunión de múltiples hilos dentro de un único
objeto y de manipulación de dichos hilos en conjunto, en lugar de una forma
individual. Por ejemplo, se pueden arrancar o suspender todos los hilos que
están dentro de un grupo con una única llamada al método. Los grupos de hilos
de Java están implementados por la clase ThreadGroup en el paquete Java.lang.

14
El runtime system (sistema de tiempo de ejecución) de Java pone un hilo
dentro de un grupo de hilos en el momento de la construcción del mismo.
Cuando creas un hilo, se puede dejar que el sistema de tiempo de ejecución
ponga el nuevo hilo en algún grupo razonable por defecto, o se puede establecer
explícitamente el grupo del nuevo hilo. El hilo es un miembro
permanente de aquel que sea el grupo de hilos al cual se unió en el momento de
su creación. No puede moverse un hilo a un nuevo grupo una vez que ha sido
creado.

1.Grupo de hilos por defecto

Si se crea un nuevo hilo sin especificar su grupo en el constructor, el sistema

de tiempo de ejecución colocará el nuevo hilo automáticamente en el mismo
grupo que el hilo que lo ha creado (conocido como grupo de hilos actual e hilo
actual, respectivamente). Así que, ¿cuál es el grupo de hilos del hilo principal de
una aplicación? Cuando se arranca una aplicación Java, el sistema de tiempo de
ejecución de Java crea una instancia de la clase ThreadGroup llamada main. A
menos que especifiques lo contrario,
Todos los nuevos hilos que crees se convertirán en miembros del grupo de hilos
main.

2.Grupo de hilos de forma explicita

Como hemos mencionado anteriormente, un hilo es un miembro permanente de

aquel grupo de hilos al cual se unió en el momento de su creación (no tenemos la
posibilidad de cambiarlo posteriormente). De este modo, si quieres poner tu
nuevo hilo en un grupo de hilos distinto del
grupo por defecto, debes especificarlo explícitamente cuando lo creas. La clase
Thread tiene tres constructores que te permiten establecer un nuevo grupo de
hilos:
• public Thread( ThreadGroup group, Runnable runnable )
• public Thread( ThreadGroup group, String name )
• public Thread( ThreadGroup group, Runnable runnable, String name )

Cada uno de estos constructores crea un nuevo hilo, lo inicializa en base a los
parámetros Runnable y String, y hace al nuevo hilo miembro del grupo
especificado. Por ejemplo, la siguiente muestra de código crea un grupo de hilos
(myThreadGroup) y entonces crea un hilo (myThread) en dicho grupo

ThreadGroup myThreadGroup = new ThreadGroup( “My Group of Threads” );

Thread myThread = new
Thread( myThreadGroup, “a thread for my group” );

15
El ThreadGroup pasado al constructor Thread no tiene que ser necesariamente
un grupo que hayas creado tú, puede tratarse de un grupo creado por el
sistema de ejecución de Java, o un grupo creado por la aplicación en la cual se
está ejecutando el applet.

Como ya hemos visto anteriormente un concepto sobre la clase ThreadGroup,

ahora lo profundizaremos más.

VII. LA CLASE ThreadGroup:

La clase ThreadGroup es la implementación del concepto de grupo de hilos en

Java. Ofrece, por tanto, la funcionalidad necesaria para la manipulación de
grupos de hilos para las aplicaciones Java. Un objeto ThreadGroup puede
contener cualquier número de hilos. Los hilos de un mismo grupo generalmente
se relacionan de algún modo, ya sea por quién los creó, por la función que llevan
a cabo, o por el momento en que deberían arrancarse y parar.

El grupo de hilos de más alto nivel en una aplicación Java es el grupo de hilos
denominado main.
• getMaxPriority y setMaxPriority
• getDaemon y SetDaemon
• getName
• getParent y parentOf
• toString
• resume
• stop
• suspend
IX. THREAD DAEMON:

Los threads daemon llamados servicios, se ejecutan con prioridad baja y

proporcionan un servicio básico a un programa o programas cuando la
actividad de la máquina es reducida.

a. Un ejemplo de thread demonio que está ejecutándose

continuamente es el recolector de basura (garbage collector). E
b. Un thread puede fijar su indicador de demonio pasando un valor
true al método setDaemon(). Si se pasa false a este método, el
thread será devuelto por el sistema como un thread de usuario.
No obstante, esto último debe realizarse antes de que se
arranque el thread (start ()).

16
VIII. SINCRONIZACION:

o Existen muchas situaciones interesantes donde ejecutar threads

concurrentes que compartan datos y deban considerar el estado y
actividad de otros threads. Este conjunto de situaciones de programación
son conocidos como escenarios 'productor/consumidor'; donde el
productor genera un canal de datos que es consumido por el consumidor.
Como los threads comparten un recurso común, deben sincronizarse de
alguna forma.

1. Uso de synchronized.

o Cada objeto tiene un “flag de bloqueo”

La palabra clave synchronized permite controlar el flag para activar

accesos exclusivos al objeto y cada objeto tendrá asociada una cola
de espera.

• Se pueden declarar bloques de código synchronized.

synchronized ( variableCompartida )

{ // acceso al recurso

• Métodos synchronized

public synchronized void nomMetode ()

{ // acceso al recurso

o El flag de bloqueo de un objeto se libera :

– Cuando el thread termina el bloque de código synchronized
– Cuando le bloque de código synchronized lanza una excepción.
o Deadlock
– Dos threads esperando un flag de bloqueo
– No se detecta
– Se puede evitar:
• Decidir el orden de obtención de los bloqueos
• Seguir con rigurosidad ese orden
• Liberar los bloqueos en orden inverso

17
2. Comunicación entre threads

o wait() y notify()
• Si un thread ejecuta una llamada wait() sobre un objeto x pausará
su ejecución hasta que otro thread ejecute la llamada a notify()
mediante el mismo objeto x.
• Para poder ejecutar tanto un wait() como un notify() el thread
deberá disponer del flag de bloqueo, es decir, solo podrán ser
ejecutadis desde un bloque de código synchronized.
• Listas de espera o “pools”

- Cuando un thread ejecuta wait() se libera el flag de bloqueo y es

colocado en la lista de espera o pool del objeto (wait pool)

-Al ejecutar notify() un thread arbitrario es movido de la lista de

espera hacia una lista de threads que esperan por el flag de
bloqueo (lock pool). notifyAll() despierta a todos los threads.

3. Monitores

o Cuando un método synchronized se ejecuta adquiere un monitor sobre el

objeto. Cuando un thread tiene el monitor del objeto ningún otro thread
podrá ejecutar un método synchronized.
o Un thread sale del monitor cuando libera el flag de bloqueo del objeto.
o Un ejemplo típico del uso de monitores es el esquema de
productor/consumidor.
o Aquí el productor y el consumidor son threads que acceden a la región
critica que es la tubería o buffer. Esta tiene que tener sus métodos
protegidos mediante synchronized y tiene que hacer que los threads se
comuniquen mediante wait(), notify() y notifyAll().

18
IX. CONCLUSIONES:

• java, que nos brinda la oportunidad de realizar distintas acciones, en

tiempo compartido,
• También conocido en java como hilos o subprocesos
• Un thread es un contexto de ejecución, proceso ligero o tarea donde
hay un flujo secuencial de control y que utiliza los recursos disponibles
para un programa.
• La Máquina Virtual Java (JVM) es un sistema multihilo.
• La diferencia básica entre un proceso de Sistema Operativo y un
Thread Java es que los hilos corren dentro de la JVM.
• A este tipo de procesos donde se comparte los recursos se les llama a
veces procesos ligeros.
• Desde el punto de vista de las aplicaciones los hilos son útiles porque
permiten que el flujo del programa sea divido en dos o más partes,
• La clase Thread es la clase responsable de producir hilos funcionales
para otras clases.
• provoca algunas limitaciones, como bien sabemos JAVA no admite la
herencia múltiple, para ello, debemos implementar la interfaz runnable.
• Para lograr añadir la funcionalidad de Hilo a una clase que deriva de
otra clase, siendo ésta distinta de Thread se utiliza la interfaz
Runnable.
• Las clases que implementan la interfaz Runnable proporcionan un
método run que es ejecutado por un objeto hilo asociado que es creado
aparte.
• La clase de error ThreadDeath proporciona un mecanismo que permite
hacer limpieza después de que un hilo haya sido finalizado de forma
asíncrona deriva de la clase Error.
• La clase ThreadGroup se utiliza para manejar un grupo de hilos de
modo conjunto
• El método wait hace que el hilo de ejecución espere en estado dormido
hasta que se le notifique que continúe. Del mismo modo, el método
notify informa a un hilo en espera de que continúe con su ejecución. El
método notifyAll es similar a notify excepto que se aplica a todos los
hilos en espera.
• Todo subproceso o hilo en java tiene una prioridad en el rango entre
Thread.MIN_PRIORITY (una constante de 1) y
Thread.MAX_PRIORITY (una constante de 10).

19