1991 Multihilo

Programación Orientada a Objetos
Trabajo Teórico
Mayo, 2004
Multihilo en Java
Raúl Herrero Pascual

Rubén Montero Diez
Departamento de Informática y Automática

Universidad de Salamanca
Información de los autores:
Raúl Herrero Pascual

Facultad de Ciencias - Universidad de Salamanca
Plaza de la Merced S/N – 37008 - Salamanca
ruly2oo2@yahoo.es
Rubén Montero Diez

Facultad de Ciencias - Universidad de Salamanca
Plaza de la Merced S/N – 37008 - Salamanca
r_montero_diez@yahoo.es
Este documento puede ser libremente distribuido.

© Programación Orientada a Objetos 2004
Resumen
En este documento se recogen los detalles fundamentales del manejo de threads en Java. No
pretende ser más que una introducción a este tema en concreto, tratando simplemente de
comentar las operaciones que se pueden realizar sobre ellos y explicar algunos detalles de su
implementación.
Estas operaciones nos determinarán los diferentes estados del ciclo de vida por el que pasa
un thread, también se explican algunas formas de sincronización para evitar problemas de
concurrencia, y por último las prioridades de los hilos para que estos se ejecuten en un
determinado orden.
Abstract
In this document the basic details for working with threads in Java are presented. It only intent
to be an introduction to this specific subject, we only try to comment the operations that we can
realize with them and explain some details of them implementation.
This operations decides the different states of the life’s cycle that a thread does, some ways
of synchronization for preventing turnout problems are also explain, and finally thread’s
priorities for that threads are executed in a fixed order.
Programación Orientada a Objetos - 2004 I

Tabla de Contenidos
1. Introducción ______________________________________________ 1
2. Multitarea y multihilo ____________________________________ 1

2.1. Programas de flujo único ____________________________________ 2
2.2. Programas de flujo múltiple __________________________________ 2
3. Creación de threads _____________________________________ 3
3.1. Construcción de una clase derivada de Thread ________________ 3
3.2. Implementación del Interface Runnable _______________________ 4
4. Paso de parámetros a los threads ____________________ 6
5. Ciclo de vida de un thread _____________________________ 7

5.1. La clase Thread _____________________________________________ 7
5.2. Métodos de Clase ___________________________________________ 7
5.3. Métodos de Instancia ________________________________________ 7
5.4. Estados de un Thread _______________________________________ 9
6. Sincronización __________________________________________ 11
6.1. Ejemplo____________________________________________________ 14
7. Prioridades y threads daemon _______________________ 19
7.1. Conmutación de contexto ___________________________________ 19
7.2. Threads daemon ___________________________________________ 20
8. Grupos de hilos _________________________________________ 20
9. Comentario_______________________________________________ 21
10. Conclusiones ____________________________________________ 22
11. Referencias ______________________________________________ 23
12. Bibliografía _______________________________________________ 23
II Programación Orientada a Objetos - 2004

Tabla de Ilustraciones
Figura 1. Disputa de CPU entre procesos pesados ____________________________ 2
Figura 2. Visualización de la salida de ThredEjemplo _________________________ 4
Figura 3. Estados de un thread ___________________________________________ 9
Figura 4. Situación de los filósofos comilones_______________________________ 14
Figura 5. Visualización de la salida del problema de los filósofos comilones ______ 18
Programación Orientada a Objetos - 2004 III

1. Introducción
Actualmente los procesadores y los sistemas operativos permiten la multitarea, es decir, la

realización simultánea de dos o más actividades, al menos aparentemente. En la realidad, un
ordenador con una sola CPU no puede realizar dos actividades a la vez. Sin embargo los
sistemas operativos modernos son capaces de ejecutar varios programas "simultáneamente"
aunque sólo dispongan de una CPU, para ello reparten el tiempo entre dos o más actividades, o
bien utilizan los tiempos muertos de una actividad, como por ejemplo en las operaciones de
lectura de datos desde el teclado, para trabajar en la otra. Mientras que en ordenadores con dos o
más procesadores la multitarea es real, ya que cada procesador puede ejecutar un hilo o thread
diferente.
Un proceso es un programa ejecutándose de forma independiente y con un espacio propio
de memoria, un sistema operativo multitarea es capaz de ejecutar más de un proceso
simultáneamente. Un thread o hilo es un flujo secuencial simple dentro de un proceso, un único
proceso puede tener varios hilos ejecutándose. Por ejemplo el programa Netscape sería un
proceso, mientras que cada una de las ventanas que se pueden tener abiertas simultáneamente
trayendo páginas HTML estaría formada por al menos un hilo.
Sin el uso de threads hay tareas que son prácticamente imposibles de ejecutar, en particular
las que tienen tiempos de espera importantes entre etapas. Los threads o hilos de ejecución
permiten organizar los recursos del ordenador de forma que pueda haber varios programas
actuando en paralelo. Un hilo de ejecución puede realizar cualquier tarea que pueda realizar un
programa normal y corriente. Bastará con indicar lo que tiene que hacer en el método run(),
que es el que define la actividad principal de las threads.
2. Multitarea y multihilo
Muchos entornos tienen la llamada multitarea en su sistema operativo, esto es distinto al
multihilo. En un sistema operativo multitarea a las tareas se les llama procesos pesados,
mientras que en un entorno multihilo se les denomina procesos ligeros o hilos, la diferencia es
que los procesos pesados están en espacios de direccionamiento distintos y por ello la
comunicación entre procesos y el cambio de contexto es caro. Por el contrario, los hilos
comparten el mismo espacio de direcciones y comparten cooperativamente el mismo proceso
pesado, cada hilo guarda su propia pila, variables locales y contador de programa, por ello, la
comunicación entre hilos es muy ligera y la conmutación de contexto muy rápida.
En la Figura 1 observamos cómo sobre una CPU pueden estar ejecutándose distintos
procesos pesados y uno de ellos puede estar compuesto por distintos flujos de ejecución
(threads o hebras o hilos). Estos threads tendrán que “disputarse” el tiempo de ejecución que el
sistema operativo le dé al proceso en el que residen.
-1-
Multihilo Java
Figura 1. Disputa de CPU entre procesos pesados
2.1. Programas de flujo único

Un programa de flujo único o single-threaded utiliza un único flujo de control para controlar su
ejecución. Muchos programas no necesitan la potencia o utilidad de múltiples flujos de control,
sin necesidad de especificar explícitamente que se quiere un único flujo de control.
Por ejemplo:
public class HolaMundo {

static public void main( String args[] ) {
System.out.println( "Hola Mundo" );
}
}
Aquí, cuando se llama a main(), la aplicación imprime el mensaje y termina. Esto ocurre
dentro de un único thread, un único hilo de ejecución.
2.2. Programas de flujo múltiple

En el ejemplo anterior no vemos el thread que ejecuta nuestro programa, se crea y se ejecuta de
forma implícita, sin embargo Java posibilita la creación y control de threads explícitamente. La
utilización de threads en Java permite una enorme flexibilidad a los programadores a la hora de
plantearse el desarrollo de aplicaciones. La simplicidad para crear, configurar y ejecutar
threads, permite que se puedan implementar aplicaciones poderosas y portables que no se puede
con otros lenguajes de tercera generación. Esta herramienta es fundamental en un lenguaje con
marcada orientación a Internet como es Java.
Las aplicaciones multithreaded utilizan muchos contextos de ejecución para cumplir su
trabajo, utilizan el hecho de que muchas tareas contienen subtareas distintas e independientes,
pudiendo utilizar un thread para cada subtarea.
Mientras que los programas de flujo único pueden realizar su tarea ejecutando las subtareas
secuencialmente, un programa multithreaded permite que cada thread comience y termine tan
pronto como sea posible. Este comportamiento presenta una mejor respuesta a la entrada en
tiempo real.
Programación Orientada a Objetos - 2004 2

Herrero y Montero
3. Creación de threads
Lo primero que hay que realizar para poder utilizar un thread es crearlo. El programador puede
elegir cualquiera de las dos posibilidades que proporciona Java, y que como explica Pedro
Manuel Cuenca en su libro [1], se describen a continuación.
3.1. Construcción de una clase derivada de Thread

La funcionalidad básica de un thread esta implementada en la clase Thread. Cualquier clase
que derive de esta puede construir un hilo de ejecución independiente, para lo cual basta con
que sobrescriba el método run(). En este método hay que incluir el código que deseamos que
se ejecute en paralelo con otras tareas. Para que comience la ejecución del thread, debe
invocarse el método start(), que después de realizar los preparativos convenientes invoca a
su vez a run().
El siguiente ejemplo demuestra la creación de un thread del modo descrito:
public class ThreadEjemplo extends Thread {

public ThreadEjemplo(String str) {
super(str);
}
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");
}
}
Notas sobre el programa:

• El constructor public Thread(String str) recibe un parámetro que es la
identificación del thread.
• El método run() contiene el bloque de ejecución del thread. Dentro de él, el método
getName() devuelve el nombre del thread, es decir, el que se ha pasado como
argumento al constructor.
• El método main() crea dos objetos de clase ThreadEjemplo y los inicia con la
llamada al método start(), dicho método después de iniciar el nuevo thread llama al
método run().
• En la salida el primer mensaje que se visualizará será el de finalización del thread
main. La ejecución de los threads es asíncrona. Realiza la llamada al método
start(), éste le devuelve el control y continua su ejecución independientemente de
los otros threads.
• En la salida los mensajes de un thread y otro se van mezclando ya que la máquina
virtual asigna tiempos a cada thread.
3 Programación Orientada a Objetos - 2004

Multihilo Java
En la Figura 2 se puede observar una de las posibles salidas por pantalla que se pueden
obtener al ejecutar este programa.
Figura 2. Visualización de la salida de ThredEjemplo
3.2. Implementación del Interface Runnable

Construir una clase derivada de Thread presenta el gran inconveniente de que para poder crear
un thread es necesario que la clase que contiene el código que se desea ejecutar en paralelo
derive de Thread. Esta limitación es muy importante ya que Java no dispone de herencia
múltiple y por ello no podremos crear un thread con cualquier clase arbitraria que herede su
funcionalidad de otras que sean de nuestro interés.
Para solventar este problema, puede utilizarse un segundo mecanismo para la creación de
un thread. Este mecanismo consiste en que la clase de nuestro interés implemente el interface
Runnable, y a continuación crearíamos un nuevo thread utilizando uno de los constructores
de la clase Thread, que admite como argumento cualquier objeto que implemente Runnable.
Este técnica no supone ninguna restricción, pues una clase puede implementar cualquier número
de interfaces.
El interface Runnable únicamente define un método denominado run() y al igual que
sucedía en el caso anterior, debemos colocar dentro del mismo el código que deseamos que se
ejecute en paralelo con otros threads.

Herrero y Montero
El siguiente ejemplo es equivalente al del apartado anterior, pero utilizando la interface

Runnable:
public class ThreadEjemplo implements Runnable {

public void run() {
for (int i = 0; i < 5 ; i++)
System.out.println(i + " " +
Thread.currentThread().getName());
System.out.println("Termina thread " +
Thread.currentThread().getName());
}
public static void main (String [] args) {
new Thread ( new ThreadEjemplo() , "Pepe").start();
new Thread ( new ThreadEjemplo() , "Juan").start();
System.out.println("Termina thread main");
}
}

• Se implanta la interface Runnable en lugar de extender la clase Thread.
• El constructor que había antes no es necesario.
• En el main() se puede observar la forma en que se crea el thread, esa expresión es
equivalente a:
ThreadEjemplo ejemplo = new ThreadEjemplo();

Thread thread = new Thread ( ejemplo , "Pepe");
thread.start();
o Primero se crea la instancia de nuestra clase.

o Después se crea una instancia de la clase Thread, pasando como parámetros la
referencia de nuestro objeto y el nombre del nuevo thread.
o Por último se llama al método start() de la clase Thread. Este método
iniciará el nuevo thread y llamará al método run() de nuestra clase.
• Por último, obsérvese la llamada al método getName() desde run(). getName()
es un método de la clase Thread, por lo que nuestra clase debe obtener una referencia
al thread propio. Es lo que hace el método estático currentThread() de la clase
Thread.

Multihilo Java
4. Paso de parámetros a los threads

El método run() no toma argumentos, sin embargo, en muchas ocasiones es necesario pasarle
parámetros a un thread. Esto se puede conseguir encapsulando el thread en una clase y pasando
los parámetros al constructor de la misma para almacenarlos en variables locales. En el
siguiente ejemplo consideramos una aplicación que crea un nuevo esclavo en un thread por cada
nuevo trabajo que le llega.
class Parametros implements Runnable

{
private int parm1;
private int parm2;
private Thread me;
public Parametros (int p1, int p2, String nombre)

{
parm1 = p1;
parm2 = p2;
me = new Thread (this,nombre);
me.start();
}
public void run()

{
if (me == Thread.currentThread())
{
System.out.println(Thread.currentThread().getName()
+"\n\tp1 = "+ parm1 + "\n\tp2 = " + parm2);
}
}
public static void main (String[] args)

{
new Parametros(4,5,"Hilo 1");
new Parametros(7,9,"Hilo 2");
}
}
Esto imprimiría:
Hilo 1
p1 = 4
p2 = 5
Hilo 2
p1 = 7
p2 = 9

Herrero y Montero
5. Ciclo de vida de un thread
5.1. La clase Thread

Es la clase que encapsula todo el control necesario sobre los hilos de ejecución (threads). Hay
que distinguir claramente un objeto Thread de un hilo de ejecución o thread. Esta distinción
resulta complicada, aunque se puede simplificar si se considera al objeto Thread como el
panel de control de un hilo de ejecución. La clase Thread es la única forma de controlar el
comportamiento de los hilos y para ello se sirve de los métodos que se exponen a continuación.
5.2. Métodos de Clase

Estos son los métodos estáticos que deben llamarse de manera directa en la clase Thread.
¾ currentThread(): este método devuelve el thread que se está ejecutando en este

momento, es decir, aquél desde donde se produjo la invocación a
currentThread().
¾ yield(): este método libera el procesador para que pueda ser utilizado por otros
threads. Esto no significa que el thread se detenga definitivamente, sino que
simplemente indica al planificador que pase a ejecutar otro thread. El thread que invocó
a yield() se volverá a ejecutar cuando le toque el turno de nuevo.
¾ sleep(long): este método interrumpe la ejecución del hilo en curso durante el

número de milisegundos que se indiquen en el parámetro de tipo long. Una vez
transcurridos esos milisegundos, dicho hilo volverá a estar disponible para su ejecución.
¾ activeCount(): este método devuelve el número de threads activos dentro del

grupo donde está incluido el thread en ejecución.
5.3. Métodos de Instancia

¾ start(), stop(), run(), destroy(): estos métodos son los que controlan
el funcionamiento básico del thread. El método start() se invoca cuando se desea
comenzar la ejecución del thread. La implementación de la clase Thread realiza
diversas tareas de iniciación antes de pasar a invocar el método run(). El
programador puede utilizar start() para añadir código adicional de inicialización,
aunque esto sólo es posible si se crea una subclase de Thread. Como puede
imaginarse, stop() sirve para indicar al thread que debe terminar su ejecución,
mientras que destroy() tiene como cometido liberar todos los recursos que pudieran
estar empleándose.
¾ getName(), setName(): los threads pueden tener asociado un nombre, lo que

facilita las labores de depuración o incluso la creación de trazas en el código para
supervisar la ejecución, una de las formas para asignar este nombre es mediante el
método setName(). En cuanto a la depuración cabe destacar que la realización de

Multihilo Java
programas con varios threads es considerablemente más compleja y difícil de depurar

que el desarrollo de aplicaciones sin esta capacidad.
Además del método setName(), existen constructores de la clase Thread en los
que se pueden especificar el nombre que se desea asignar.
¾ getPriority(), setPriotity(): puede asignarse una prioridad a cada

thread, de modo que se asigne más tiempo de ejecución a los threads más prioritarios.
Esto es todo lo que Java permite profundizar sobre el estudio de la prioridad, siendo
imposible conocer cómo se realizará la planificación entre threads de igual prioridad.
La prioridad de un thread ha de estar comprendida entre los valores MIN_PRIORITY y
MAX_PRIORITY. Cuando se crea un thread, recibe por defecto la prioridad
NORM_PRIORITY.
¾ getThreadGroup(): este método obtiene el grupo donde está contenido el thread.

No existe un método setThreadGroup(), por consiguiente, debe emplearse alguna
versión del constructor para indicar el grupo a donde se desea que pertenezca el thread.
¾ 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. 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.
¾ isAlive(): el interfaz de programación de la clase Thread incluye el método

isAlive(), que devuelve true si el hilo ha sido arrancado (con start()) y no ha
sido detenido (con stop()). Por ello, si el método isAlive() devuelve false;
sabemos que estamos ante un Nuevo thread o ante un thread Muerto, y si devuelve
true; se sabe que el hilo se encuentra en estado Ejecutable o Parado, todos estos estados
se explican en el siguiente apartado. No se puede diferenciar entre Nuevo thread y
Muerto, ni entre un hilo Ejecutable o Parado.
¾ join(): este método detiene el hilo actual hasta que termine el hilo sobre el que se
llama join(). Es usado por tanto para que unos hilos esperen a la finalización de
otros.
Se acaban de explicar los métodos de clase y métodos de instancia más interesantes dentro
del ámbito de este trabajo. Pero existen muchos más y se pueden consultar en la página web de
Sun [2].

Herrero y Montero
5.4. Estados de un Thread

Durante el ciclo de vida de un hilo, éste se puede encontrar en diferentes estados. En la Figura 3
se muestran los estados y algunos métodos que provocan el paso de un estado a otro.
Figura 3. Estados de un thread
5.4.1 Nuevo thread

Las siguientes sentencias crean un nuevo hilo de ejecución pero no lo arrancan, lo dejan en el
estado de Nuevo thread:
Thread MiThread = new MiClaseThread("hiloA");

Thread MiThread = new Thread( new UnaClaseThread,"hiloA");
Cuando un hilo está en este estado, es simplemente un objeto Thread vacío. El sistema no
ha destinado ningún recurso para él, únicamente memoria. Desde este estado solamente puede
arrancarse llamando al método start(), o detenerse definitivamente, llamando al método
stop(). La llamada a cualquier otro método carece de sentido y lo único que provocará será la
generación de una excepción de tipo IllegalThreadStateException.
5.4.2 Ejecutable
Obsérvense las dos líneas de código siguientes:
Thread MiThread = new MiClaseThread();

MiThread.start();
La llamada al método start() reservará los recursos del sistema necesarios para que el
hilo pueda ejecutarse, lo incorpora a la lista de procesos disponibles para ejecución del sistema y
llama al método run() del hilo de ejecución. En este momento se encuentra en el estado

Multihilo Java
Ejecutable del diagrama. Y este estado es Ejecutable y no En Ejecución, porque cuando el hilo
está aquí no significa que esté corriendo. Muchos ordenadores tienen solamente un procesador
lo que hace imposible que todos los hilos estén corriendo al mismo tiempo. Java implementa un
tipo de scheduling o lista de procesos, que permite que el procesador sea compartido entre todos
los procesos o hilos que se encuentran en la lista.
Cuando el hilo se encuentra en este estado, todas las instrucciones de código que se
encuentren dentro del bloque declarado para el método run(), se ejecutarán secuencialmente.
5.4.3 Parado
Un hilo de ejecución entra en estado Parado cuando alguien llama al método suspend(),
cuando se llama al método sleep(), cuando el hilo está bloqueado en un proceso de
entrada/salida o cuando el hilo utiliza su método wait() para esperar a que se cumpla una
determinada condición.
Por ejemplo, en el trozo de código siguiente:
MiThread.start();
try {
MiThread.sleep( 10000 );
} catch( InterruptedException e ) {}
la línea de código que llama al método sleep() hace que el hilo se duerma durante 10
segundos. Durante ese tiempo, incluso aunque el procesador estuviese totalmente libre,
MiThread no correría. Después de esos 10 segundos MiThread volvería a estar en estado
Ejecutable y ahora sí que el procesador podría hacerle caso cuando se encuentre disponible.
Los métodos de recuperación del estado Ejecutable, en función de la forma de llegar al
estado Parado del hilo, son los siguientes:
• Si un hilo está dormido, pasado el tiempo especificado en el sleep().
• Si un hilo de ejecución está suspendido, después de una llamada a su método
resume().
• Si un hilo está bloqueado en una entrada/salida, una vez que el comando de
entrada/salida concluya su ejecución.
• Si un hilo está esperando por una condición, cada vez que la variable que controla esa
condición varíe debe llamarse al método notify() o notifyAll() .
5.4.4 Muerto
Un hilo de ejecución se puede morir de dos formas: por causas naturales o porque lo maten (con
stop()). Un hilo muere normalmente cuando concluye su método run().
Por ejemplo, en el siguiente trozo de código:
public void run() {

int i=0;
while( i < 20 ) {
i++;
System.out.println( "i = " + i );
}
}

Herrero y Montero
un hilo morirá de forma natural después de que se complete el bucle y run() concluya.
También se puede matar en cualquier momento un hilo, invocando a su método stop(),
en el trozo de código siguiente:
MiThread.start();
try {
MiThread.sleep( 10000 );
} catch( InterruptedException e ) {}
MiThread.stop();
se crea y arranca el hilo MiThread, se duerme durante 10 segundos y en el momento de

despertarse, la llamada al método stop() lo mata.
El método stop() envía un objeto ThreadDeath al hilo de ejecución que quiere
detener. Así, cuando un hilo es parado de este modo, muere asíncronamente. El hilo morirá en el
momento en que reciba ese objeto ThreadDeath.
Los applets utilizarán el método stop() para matar a todos sus hilos cuando el navegador
con soporte Java en el que se están ejecutando le indica al applet que se detengan, por ejemplo,
cuando se minimiza la ventana del navegador o cuando se cambia de página.
6. Sincronización
La sincronización surge debido a la necesidad de evitar que dos o más threads traten de acceder
a los mismos recursos al mismo tiempo. Por ejemplo si un thread tratara de escribir en un
fichero y otro thread estuviera al mismo tiempo tratando de borrar dicho fichero, se produciría
una situación no deseada. También habría que sincronizar hilos cuando un thread debe esperar a
que estén preparados los datos que le debe suministrar otro thread. Para solucionar estos tipos
de problemas es importante poder sincronizar los distintos threads.
Las secciones de código de un programa que acceden a un mismo recurso (un mismo
objeto de una clase, un fichero del disco, etc.) desde dos threads distintos se denominan
secciones críticas. Para sincronizar dos o más threads, hay que utilizar el modificador
synchronized en aquellos métodos del objeto o recurso con los que puedan producirse
situaciones conflictivas. De esta forma Java bloquea, asocia un bloqueo o lock, el recurso
sincronizado. Por ejemplo:
public synchronized void metodoSincronizado() {
...// código de la sección critica
}
La sincronización previene las interferencias solamente sobre un tipo de recurso: la

memoria reservada para un objeto. Cuando se prevea que unas determinadas variables de una
clase pueden tener problemas de sincronización, se deberán declarar como private o
protected. Así solamente serán accesibles a través de métodos de la clase, los cuales
deberán estar sincronizados. Es muy importante tener en cuenta que si se sincronizan algunos
métodos de un objeto pero otros no, el programa puede que no funcione correctamente. La
razón es que los métodos no sincronizados pueden acceder libremente a las variables miembro
ignorando el bloqueo del objeto, sólo los métodos sincronizados comprueban si un objeto está
bloqueado.

Multihilo Java
Todos los métodos que accedan a un recurso compartido deben ser declarados
synchronized. De esta forma, si algún método accede a un determinado recurso Java
bloquea dicho recurso, así logramos que el resto de threads no puedan acceder al mismo hasta
que el primero en acceder termine de realizar su tarea. Bloquear un recurso u objeto significa
que sobre ese objeto no pueden actuar simultáneamente dos métodos sincronizados.
En la sincronización se pueden utilizar dos niveles de bloqueo de un recurso, el primero es
a nivel de objetos, mientras que el segundo es a nivel de clases. El primero se consigue
declarando todos los métodos de una clase como synchronized. Cuando se ejecuta un
método synchronized sobre un objeto concreto, el sistema bloquea dicho objeto, de forma
que si otro thread intenta ejecutar algún método sincronizado de ese objeto, este segundo
método se mantendrá a la espera hasta que finalice el anterior y desbloquee por lo tanto el
objeto. Si existen varios objetos de una misma clase, como los bloqueos se producen a nivel de
objeto, es posible tener distintos threads ejecutando métodos sobre diversos objetos de una
misma clase.
El bloqueo de recursos a nivel de clases se corresponde con los métodos de clase o
static, y por lo tanto con las variables de clase o static. Si lo que se desea es conseguir
que un método bloquee simultáneamente una clase entera, es decir, todos los objetos creados de
una clase, será necesario declarar este método como synchronized static. Durante la
ejecución de un método declarado de esta segunda forma ningún método sincronizado tendrá
acceso a ningún objeto de la clase bloqueada.
La sincronización puede ser problemática y generar errores. Un thread podría bloquear un
determinado recurso de forma indefinida impidiendo que el resto de threads accedieran al
mismo, para evitar esto habrá que utilizar la sincronización sólo donde sea estrictamente
necesario.
Hay que tener presente que si dentro de un método sincronizado se utiliza el método
sleep() de la clase Thread, el objeto bloqueado permanecerá dormido durante el tiempo
indicado en el argumento de dicho método. Esto implica que otros threads no podrán acceder a
ese objeto durante ese tiempo, aunque en realidad no exista peligro de simultaneidad ya que
durante ese tiempo el thread que mantiene bloqueado el objeto no realizará cambios. Para
evitarlo es conveniente sustituir sleep() por el método wait(). Cuando se llama al método
wait(), que siempre debe hacerse desde un método o bloque synchronized, se libera el
bloqueo del objeto y por lo tanto es posible continuar utilizando ese objeto a través de métodos
sincronizados. El método wait() detiene el thread hasta que se llame al método notify() o
notifyAll() del objeto, o finalice el tiempo indicado como argumento del método wait().
El método unObjeto.notify() lanza una señal indicando al sistema que puede activar uno
de los threads que se encuentren bloqueados esperando para acceder al objeto unObjeto. El
método notifyAll() lanza una señal a todos los threads que están esperando la liberación
del objeto.
Los métodos notify() y notifyAll() deben ser llamados desde el thread que tiene
bloqueado el objeto para activar el resto de threads que están esperando la liberación de un
objeto. Un thread se convierte en propietario del bloqueo de un objeto ejecutando un método
sincronizado del objeto.
Observar las dos funciones siguientes, en las que put() inserta un dato y get() lo
recoge:

Herrero y Montero
public synchronized int get() {

while (available == false) {
try {
wait();
} catch (InterruptedException e) { }
}
available = false;
notifyAll();
return contents;
}
public synchronized void put(int value) {

while (available == true) {
try {
wait();
} catch (InterruptedException e) { }
}
contents = value;
available = true;
notifyAll();
}
• El bucle while de la función get() continúa ejecutándose (avalaible ==
false) hasta que el método put() haya suministrado un nuevo valor y lo indique
con avalaible = true.
• En cada iteración del while la función wait() hace que el hilo que ejecuta el
método get() se detenga hasta que se produzca un mensaje de que algo ha sido
cambiado, en este caso con el método notifAll() ejecutado por put().
• El método put() funciona de forma similar.
También existe la posibilidad de sincronizar una parte del código de un método sin
necesidad de mantener bloqueado el objeto desde el comienzo hasta el final del método. Para
ello se utiliza la palabra clave syncronized indicando entre paréntesis el objeto que se desea
sincronizar (synchronized(objetoASincronizar)). Por ejemplo si se desea
sincronizar el propio thread en una parte del método run(), el código podría ser:
public void run() {
while(true) {
...
syncronized(this) {
// El objeto a sincronizar es el propio thread
... // Código sincronizado
}
try {
sleep(2000);
// Se detiene el thread durante 2 segundos pero el objeto
// es accesible por otros threads al no estar sincronizado
} catch(InterruptedException e) {}
}
}

Multihilo Java
Un thread puede llamar a un método sincronizado de un objeto para el cual ya posee el

bloqueo, volviendo a adquirir el bloqueo. Por ejemplo:
public class VolverAAdquirir {
public synchronized void a() {
b();
System.out.println("Estoy en a()");
}
public synchronized void b() {
System.out.println("Estoy en b()");
}
}
El anterior ejemplo obtendrá como salida:
Estoy en b()
Estoy en a()
debido a que se ha podido acceder al objeto con el método b() al ser el thread que ejecuta el
método a() propietario con anterioridad del bloqueo del objeto.
El proceso de sincronización lleva bastante tiempo a la CPU, por ello se debe minimizar su
uso ya que el programa será más lento cuanta más sincronización incorpore.
6.1. Ejemplo
EL PROBLEMA DE LOS FILÓSOFOS COMILONES.
Cinco filósofos pasan su vida pensando y comiendo. Los filósofos comparten una mesa
circular rodeada por cinco sillas, una para cada uno de ellos. En el centro de la mesa se
encuentra una fuente de arroz, y también sobre la mesa hay cinco palillos chinos. Cuando un
filósofo piensa, no interactúa con sus colegas. Ocasionalmente, un filósofo tiene hambre y trata
de coger los dos palillos que están más cerca de él (los palillos colocados entre él y sus vecinos
de la derecha y de la izquierda). Un filósofo sólo puede coger un palillo a la vez y, obviamente,
no puede ser el que está en la mano de un vecino. Cuando un filósofo hambriento tiene sus dos
palillos al mismo tiempo, come sin soltarlos. Cuando termina de comer, coloca ambos palillos
sobre la mesa y comienza a pensar otra vez.
La situación de los Filósofos comelones se puede observar en la Figura 4.
Figura 4. Situación de los filósofos comilones

Herrero y Montero
class semAforo
{
private int valor=1;
synchronized void decrementar()

{
while(valor<=0)
{
try{
wait();
}catch(InterruptedException e)
{}
}
valor--;
}
synchronized void incrementar()

{
valor++;
notify();
}
}
class pensadores1 extends Thread

{
private int number;
private semAforo palillo_izq;
private semAforo palillo_der;
long dormir;
Random alea=new Random(1);
public pensadores1(semAforo izq,semAforo der,int num)

{
palillo_izq=izq;
palillo_der=der;
this.number=num;
}
public void run()

{
for(;;)
{
palillo_izq.decrementar();
System.out.println("<"+this.number+"> Conseguido
palillo izquierdo");
palillo_der.decrementar();
palillo derecho");
System.out.println("<"+this.number+"> Estoy
comiendo");
try {
dormir=(alea.nextInt(4))+10;
sleep(dormir*1000);

Multihilo Java
} catch (InterruptedException e)
{}
pensando");
palillo_izq.incrementar();
palillo_der.incrementar();
try {
sleep(dormir*1000);
{}
}
}
}
class pensadores2 extends Thread
{
private int number;
private semAforo palillo_izq;
private semAforo palillo_der;
long dormir;
Random alea=new Random(2);
public pensadores2(semAforo izq,semAforo der,int num)

{
palillo_izq=izq;
palillo_der=der;
this.number=num;
}
public void run()

{
for(;;)
{
palillo_der.decrementar();
palillo derecho");
palillo_izq.decrementar();
palillo izquierdo");
comiendo");
try {
sleep(dormir*1000);
{}
pensando");
palillo_izq.incrementar();
palillo_der.incrementar();
try {

Herrero y Montero
sleep(dormir*1000);
{}
}
}
}
class probar
{
public static void main(String args[])
{
semAforo palillo1=new semAforo();
pensadores1 p1=new pensadores1(palillo1,palillo2,1);

try
{
p1.start();
p2.start();
p3.start();
p4.start();
p5.start();
p1.join();
p2.join();
p3.join();
p4.join();
p5.join();
}catch(java.lang.InterruptedException ie)
{
System.out.println(ie);
}
}
}

Multihilo Java
En la Figura 5 se puede observar una de las posibles salidas por pantalla que se pueden
obtener al ejecutar este programa.
Figura 5. Visualización de la salida del problema de los filósofos comilones

• Tenemos dos clases de pensadores; pensadores1 y pensadores2, que se
diferencian en que uno coge primero el palillo izquierdo y otro el palillo derecho.
Tenemos además otras dos clases; la clase semAforo y la clase probar que definirá
el método main().
• La clase semAforo tiene dos métodos; incrementar() y decrementar() que
nos sirven para controlar que los palillos sólo sean utilizados por un solo filósofo, esto
se consigue haciendo que esta operación sea de forma atómica y así prevenir la
concurrencia, para ello se declaran como synchronized y se usan los métodos
wait y notify.
• La clase pensadores1 extiende la clase Thread (la hereda) y por ello no es
necesario implementar el Runnable. Esta clase además del constructor, tiene un
método run() que va a determinar las acciones a realizar por cada hilo, es decir, por
cada filósofo. Estos lucharán por conseguir el palillo de su izquierda, a continuación el
de la derecha, y posteriormente comerán. Después de comer, dormirán un tiempo
aleatorio y los soltarán para que los demás los utilicen.
• La clase pensadores2 es exactamente igual que la clase pensadores1 con la
salvedad de que el orden en coger los palillos es al contrario para evitar que se produzca
un interbloqueo debido a que todos los filósofos cojan su palillo izquierdo y esperen por
el derecho.

Herrero y Montero
• La clase probar esta constituida por el método principal, es decir, el método main()
que nos sirve para ejecutar el programa y utilizar las clases anteriormente definidas. En
él se instancian varios objetos, de los cuales los de la clase pensadores1 y
pensadores2 llamarán al método start() para iniciar la ejecución de dichos hilos
(implícitamente se llamará también a run()) y se lleven a cabo las operaciones
implementadas, con lo que conseguiremos solucionar el problema. Por último
esperamos por la finalización de los hilos mediante el método join().
7. Prioridades y threads daemon

Para conseguir una correcta ejecución de un programa se establecen prioridades en los threads,
de forma que se produzca un reparto más eficiente de los recursos disponibles. Así, en un
determinado momento, interesará que un determinado proceso acabe lo antes posible sus
cálculos, de forma que habrá que otorgarle más recursos, más tiempo de CPU. Esto no significa
que el resto de procesos no requieran tiempo de CPU, sino que necesitarán menos. La forma de
llevar a cabo esto es gracias a las prioridades.
Cuando se crea un nuevo thread, éste hereda la prioridad del thread desde el que ha sido
inicializado. Las prioridades vienen definidas por variables miembro de la clase Thread, que
toman valores enteros que oscilan entre la máxima prioridad MAX_PRIORITY (normalmente
tiene el valor 10) y la mínima prioridad MIN_PRIORITY (valor 1), siendo la prioridad por
defecto NORM_PRIORITY (valor 5). Para modificar la prioridad de un thread se utiliza el
método setPriority(). Se obtiene su valor con getPriority().
7.1. Conmutación de contexto

Las reglas para la conmutación de contexto entre threads son sencillas. Un hilo puede ceder
voluntariamente el control (por abandono explícito, al quedarse dormido o al bloquearse en
espera de una E/S pendiente), o puede ser desalojado. En el primer caso, se examinan todos los
demás restantes y se selecciona aquel que, estando listo para su ejecución, tenga la prioridad
más alta, para su asignación a la CPU. En el segundo caso, un hilo de baja prioridad que no
libera la CPU es desalojado por otro de mayor prioridad, con independencia de lo que estuviese
haciendo en ese instante. En otras palabras, tan pronto como un hilo de mayor prioridad desee
comenzar su ejecución, lo hará. Esto se suele conocer como multitarea por desalojo.
En caso de tareas con igual prioridad se suele aplicar algún algoritmo de round-robin para
conmutar entre tareas.
Un thread puede en un determinado momento renunciar a su tiempo de CPU y otorgárselo
a otro thread de la misma prioridad, mediante el método yield(), aunque en ningún caso a un
thread de prioridad inferior.

Multihilo Java
7.2. Threads daemon

Los threads pueden ser daemon o no daemon. Son daemon aquellos hilos que realizan en
background (en un segundo plano) servicios generales, es decir, tareas que no forman parte de
la esencia del programa y que se están ejecutando mientras no finalice la aplicación. Un thread
daemon podría ser por ejemplo aquél que está comprobando permanentemente si el usuario
pulsa un botón. Un programa de Java finaliza cuando sólo quedan corriendo threads de tipo
daemon. Por defecto, y si no se indica lo contrario, los threads son del tipo no daemon.
Los thread Daemon tienen la prioridad más baja. Se usa el método setDaemon (true)
para marcar un thread como thread demonio y se usa getDaemon para comprobar ese
indicador. Por defecto, la cualidad de demonio se hereda desde el thread que crea el nuevo
thread. No puede cambiarse después de haber iniciado un thread.
8. Grupos de hilos
Cualquier hilo de ejecución en Java debe formar parte de un grupo, la clase ThreadGroup
define e implementa la capacidad de un grupo de hilos.
Los grupos de hilos permiten que sea posible recoger varios hilos de ejecución en un solo
objeto y manipularlo como un grupo, en vez de individualmente. Por ejemplo, se pueden
regenerar los hilos de un grupo mediante una sola sentencia.
Cuando se crea un nuevo hilo, se coloca en un grupo, bien indicándolo explícitamente, o
bien dejando que el sistema lo coloque en el grupo por defecto. Una vez creado el hilo y
asignado a un grupo, ya no se podrá cambiar a otro grupo.
Si no se especifica un grupo en el constructor, el sistema coloca el hilo en el mismo grupo
en que se encuentre el hilo de ejecución que lo haya creado, y si no se especifica el grupo para
ninguno de los hilos, entonces todos serán miembros del grupo main, que es creado por el
sistema cuando arranca la aplicación.
La clase Thread proporciona constructores en los que se puede especificar el grupo del
hilo que se esta creando en el mismo momento de instanciarlo, y también métodos como
getThreadGroup(), que permiten determinar el grupo en que se encuentra un hilo de
ejecución.

Herrero y Montero
9. Comentario
La posibilidad de soportar varios threads nos proporciona una gran flexibilidad para el diseño
de aplicaciones.
La especificación de Java sólo menciona que pueden utilizarse los recursos del sistema
operativo subyacente si éste soporta multithreading, en caso contrario es la maquina virtual
quien realiza todas las labores de planificación y cambio de contexto.
El comportamiento que puede esperar el programador del soporte de multithreading en
Java no permite la realización de aplicaciones con fuertes requisitos temporales. No es posible
tan siquiera cambiar la política de planificación de la maquina virtual, y lo que es peor, ésta
depende de la plataforma en la que nos encontremos. Debido a estos motivos la utilización de
multithreading en Java debe limitarse simplemente a situaciones donde sea conveniente tener
varias tareas en paralelo, sin que importe demasiado la precisión con que se reparten el
procesador o la frecuencia con que realizan cambios de contexto.
Existe un aspecto significativo y no intuitivo dentro de los hilos, y es que debido a la
planificación de los hilos, se puede hacer que una aplicación se ejecute generalmente más rápido
insertando llamadas a sleep() dentro del bucle principal de run(). Debido a esto su uso
parece un arte, sobre todo cuando unos retrasos más largos parecen incrementar el rendimiento.
La razón por la que ocurre esto es que retrasos más breves pueden hacer que la interrupción del
planificador del final de sleep() se dé antes de que el hilo en ejecución este listo para ir a
dormir, forzando así al planificador a detenerlo y volver a arrancarlo más tarde para que pueda
acabar con lo que estaba haciendo, para ir después a dormir.
Las desventajas principales del multihilado son:
1. Ralentización durante la espera por recursos compartidos.
2. Sobrecarga adicional de la CPU necesaria para gestionar los hilos.
3. Complejidad sin recompensa, como la idea poco acertada de tener un hijo separado para
actualizar cada elemento de un array.
4. Problemas derivados como la inanición, la competición y el interbloqueo.

Multihilo Java
10. Conclusiones
• La programación de hilos requiere un cambio en la forma de pensar al programar, ya

que la ejecución del código ya no se realiza de forma secuencial sino paralelamente.
• Tiene suma importancia saber cuándo hay que hacer uso de threads y cuándo evitarlos.
Las principales razones de usarlos son al gestionar varias tareas que al entremezclarse
hagan un uso más eficiente del ordenador, o porque al usuario le interese por una
determinada circunstancia.
• Un único hilo es similar a un programa secuencial; es decir, tiene un comienzo, una
secuencia y un final, además en cualquier momento durante la ejecución existe un sólo
punto de ejecución. Sin embargo, un hilo no es un programa; no puede correr por sí
mismo, corre dentro de un programa. Un hilo por si mismo no nos ofrece nada nuevo,
es la habilidad de ejecutar varios hilos dentro de un programa lo que ofrece algo nuevo
y útil, ya que cada uno de estos hilos puede ejecutar tareas distintas.
• Una ventaja de usar hilos es que las conmutaciones de contexto de procesos ligeras,
sustituyen a las conmutaciones de contexto de procesos pesadas. Debido a que todos los
hilos de un determinado proceso comparten el mismo espacio de memoria, una
conmutación del proceso ligera sólo cambia la ejecución del programa y las variables
locales, mientras que una conmutación de contexto pesada debe intercambiar todo el
espacio en memoria.
• La mayor dificultad de trabajar con hilos es que dado un recurso, este podría estar
siendo compartido por más de un hilo. Por ello hay que asegurarse de que varios hilos
no intenten leer y cambiar un recurso simultáneamente. Esto requiere de un uso
cuidadoso de synchronized, ya que aunque es una herramienta muy útil, puede
llevar a situaciones de interbloqueo sin darnos cuenta.
• Los programas paralelos son usados en ambientes críticos y muy sensibles tales como
operaciones y manipulación en bases de datos, recolección de información, etc. Con un
creciente énfasis en el Web y herramientas independientes de la plataforma, es por esto
que Java ha tenido un gran impacto en la creación de nuevos sistemas paralelo. El
problema es que Java soporta hilos, pero no ofrece una protección adecuada para los
recursos compartidos por los hilos y no tiene un mecanismo de detección de
interbloqueos.
• En Java parece que existe un límite en la cantidad de hilos a crear, ya que en algunas
ocasiones un número de hilos muy elevado da muestras de colapso, este punto crítico
puede que se alcance con unos pocos cientos. Normalmente sólo se crean unos pocos
hilos para solucionar un problema y por tanto este límite no se suele alcanzar, aunque
puede parecer una limitación en grandes diseños.

Herrero y Montero
11. Referencias
[1] Pedro Manuel Cuenca Jiménez. “Programación en Java”. Guía Práctica para
programadores. Anaya Multimedia.
[2] API de Java. Web Site.

http://java.sun.com/j2se/1.4.2/docs/api/index.html [Última vez visitado, 8-6-2004]
12. Bibliografía
• Ed Tittel, Bill Brogden. “Manual Fundamental de Java”. Anaya Multimedia.
• H. M. Deitel, P. J. Deitel . “Cómo programar en Java“. Prentice-Hall

Hispanoamericana. 1a. Ed.
• Bruce Eckel; traducción, Jorge González Barturen. “Piensa en Java “. Prentice

Hall.
• Roger Cadenhead. “Java 2 in 24 hours”. Sams Publising.
• Página web con información acerca de varios lenguajes de programación en general, y

de Java en particular.
http://www.programacion.net/java/ [Última vez visitado, 8-6-2004]
• Página oficial de Sun dedicada al lenguaje Java.

http://java.sun.com/ [Última vez visitado, 8-6-2004]
• Página con varios tutoriales sobre Java y threads.

http://programacion.com/java/tutorial/threads/ [Última vez visitado, 8-6-2004]
• Página web en español dedicada íntegramente al lenguaje Java.

http://www.javahispano.org/ [Última vez visitado, 8-6-2004]
• El rincón de Java.
http://wwws.uib.es/rincon/java/ [Última vez visitado, 8-6-2004]

1991 Multihilo

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

1991 Multihilo

Uploaded by

Copyright:

Available Formats

Programación Orientada a Objetos

Raúl Herrero Pascual

Departamento de Informática y Automática

Raúl Herrero Pascual

Rubén Montero Diez

Este documento puede ser libremente distribuido.

Programación Orientada a Objetos - 2004 I

2. Multitarea y multihilo ____________________________________ 1

5. Ciclo de vida de un thread _____________________________ 7

10. Conclusiones ____________________________________________ 22

11. Referencias ______________________________________________ 23

12. Bibliografía _______________________________________________ 23

II Programación Orientada a Objetos - 2004

Programación Orientada a Objetos - 2004 III

Actualmente los procesadores y los sistemas operativos permiten la multitarea, es decir, la

Figura 1. Disputa de CPU entre procesos pesados

2.1. Programas de flujo único

public class HolaMundo {

2.2. Programas de flujo múltiple

Programación Orientada a Objetos - 2004 2

3.1. Construcción de una clase derivada de Thread

public class ThreadEjemplo extends Thread {

Notas sobre el programa:

3 Programación Orientada a Objetos - 2004

Figura 2. Visualización de la salida de ThredEjemplo

3.2. Implementación del Interface Runnable

Programación Orientada a Objetos - 2004 4

El siguiente ejemplo es equivalente al del apartado anterior, pero utilizando la interface

public class ThreadEjemplo implements Runnable {

Notas sobre el programa:

ThreadEjemplo ejemplo = new ThreadEjemplo();

o Primero se crea la instancia de nuestra clase.

5 Programación Orientada a Objetos - 2004

4. Paso de parámetros a los threads

class Parametros implements Runnable

public Parametros (int p1, int p2, String nombre)

public void run()

public static void main (String[] args)

Programación Orientada a Objetos - 2004 6

5. Ciclo de vida de un thread

5.1. La clase Thread

5.2. Métodos de Clase

¾ currentThread(): este método devuelve el thread que se está ejecutando en este

¾ sleep(long): este método interrumpe la ejecución del hilo en curso durante el

¾ activeCount(): este método devuelve el número de threads activos dentro del

5.3. Métodos de Instancia

¾ getName(), setName(): los threads pueden tener asociado un nombre, lo que

7 Programación Orientada a Objetos - 2004

programas con varios threads es considerablemente más compleja y difícil de depurar

¾ getPriority(), setPriotity(): puede asignarse una prioridad a cada

¾ getThreadGroup(): este método obtiene el grupo donde está contenido el thread.

¾ suspend(): el método suspend() es distinto de stop(). suspend() toma el

¾ resume(): el método resume() se utiliza para revivir un hilo suspendido. No hay

¾ isAlive(): el interfaz de programación de la clase Thread incluye el método

Programación Orientada a Objetos - 2004 8

5.4. Estados de un Thread

Figura 3. Estados de un thread

5.4.1 Nuevo thread

Thread MiThread = new MiClaseThread("hiloA");

Thread MiThread = new MiClaseThread();

9 Programación Orientada a Objetos - 2004

public void run() {

Programación Orientada a Objetos - 2004 10