Clase Thread - docencia de la ETSIT-URJC

Tema 14: Concurrencia
Introducción a Java
GSyC, 2007

Introducción
Las aplicaciones normalmente están compuestas de un
único flujo de ejecución que ejecuta todas las
instrucciones del programa
Java proporciona soporte para la programación de
aplicaciones concurrentes: varios flujos de ejecución
simultáneos en el mismo programa
Un Thread es un flujo/hilo de ejecución, (tarea en
Ada). Es una CPU virtual.
En Java se pueden crear múltiples threads, además
del flujo principal que da comienzo al programa,
ejecutándose todos concurrentemente
2

Introducción
Un thread está compuesto por:
• Código que ejecuta el thread
• Datos que consulta/modifica el thread
• Prioridad del thread: utilizada para que el planificador decida qué thread ejecutar
cuando hay varios posibles
Cómo se implementan los threads
• Cuando se interrumpe la ejecución de un thread se salva el contador de programa, los
registros y su pila para poder recuperar su estado cuando se continúe su ejecución
• Puede haber un thread por procesador en máquinas multiprocesadoras, o un thread
por cada proceso del sistema operativo (SO), o un thread por cada “proceso ligero”
del SO, o múltiples threads por cada proceso del SO, controlados por un planificador
que corre en espacio de usuario
El soporte para threads lo puede proporcionar el propio lenguaje, o una biblioteca aparte

Introducción
Aspectos a tener en cuenta al añadir threads a un
lenguaje de programación
• Políticas de planificación de los threads
• Cómo modelar la periodicidad
• Cómo implementar los threads: estructuras de control
nuevas, o módulos especiales, o métodos especiales en
módulos de la biblioteca
• Cómo expresar el procesamiento que se llevará a cabo
• Cómo expresar la semántica del ciclo de vida de un thread:
creación, arranque, parada
• Cómo modelar la sincronización y comunicación entre threads
Cómo evitar condiciones de carrera: problemas que surgen al
compartir estructuras de datos entre threads

Threads en Java
Planificación de threads
• Cada thread tiene su prioridad
• Si hay más threads que procesadores en el ordenador, se elige el
thread que se ejecutará según su prioridad
2 posibilidades, dependientes de la implementación:
Política expulsiva: cada cierto tiempo se le quita el procesador al
thread que lo tiene
Política no expulsiva: hasta que no se bloquea un thread no se le
quita el procesador
Ejecución periódica de threads
• El método sleep (n) suspende la ejecución del thread durante al
menos n milisegundos

Threads en Java
Java integra los threads con la orientación a objetos
• Un thread es un objeto cuya clase hereda de java.lang.Thread
• El código que ejecutará el thread se escribe en su método
run().
• ¡El método run() NO se debe, aunque se puede, invocar
directamente!
Ciclo de vida del thread
• Creación: Un thread es un objeto: se crea mediante su constructor
• Arranque: El programador invoca el método start() del thread
para iniciar su ejecución. Es este método el que invocará el método
run()
• Terminación: Un thread termina su ejecución cuando su método
run() ejecuta la sentencia return

Definición de threads
En Java se puede definir y crear un
thread de 2 formas:
• Extendiendo la clase Thread
• Se declara una subclase de Thread y se
reemplaza su método run()
• Luego se crea una instancia de la subclase
Implementando la interfaz Runnable
• Se declara una clase que implementa la
interfaz Runnable, definiendo el método
run()
• Luego se crea una instancia de esta clase y se
le pasa al constructor Thread()

Extendiendo la clase Thread
public class Nombre extends Thread {
public Nombre ( String nombre ){
super( nombre );
}
public void run() {
while( true ) {
System.out.println
(System.currentTimeMillis() + ": " + getName());
}
}
}
public class Prueba {
public static void main( String[] args ) {
Nombre n1 = new Nombre ( "Jaime" );
Nombre n2 = new Nombre ( " Lola" );
n1.start();
n2.start();
}
}
Thread principal
Thread Jaime
Thread Lola
$ java Prueba
1177437609460: Jaime
1177437609460: Lola
1177437609461: Jaime
1177437609461: Lola
1177437609461: Jaime
1177437609461: Lola
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Jaime
1177437609461: Lola
1177437609461: Jaime

Cuidado con start() y run()!
public class Prueba {
public static void main( String[] args ) {
Nombre n1 = new Nombre ( "Jaime" );
Nombre n2 = new Nombre ( " Lola" );
n1.run();
n2.run();
}
}
public class Prueba {
public static void main( String[] args ) {
Nombre n1 = new Nombre ( "Jaime" );
Nombre n2 = new Nombre ( " Lola" );
n1.start();
n2.start();
}
}

Estados del thread
Cuando se crea un thread, éste no tiene aún la capacidad de
ejecución.
Cuando se invoca al método start() el thread se encuentra en estado
de “ejecutable” (“runnable”). Eso no significa que se ejecute!!!
Cuando el planificador lo decida, el thread pasa a un estado de
“ejecutando” (“running”).
El thread puede pasar a otro estado intermedio llamado “bloqueado”
(“blocked”) si realiza una operación de bloqueo (p.e. entrada/salida)
Cuando sale del estado de bloqueo, pasa de nuevo al estado de
“ejecutable”

Implementando la interfaz Runnable
public class Nombre implements Runnable {
String nombre;
public Nombre ( String nombre ){
this.nombre = nombre;
}
public void run() {
while( true ) {
System.out.println
(System.currentTimeMillis() + ": " + nombre);
}
}
}
public class Prueba {
public static void main( String[] args ) {
Runnable n1 = new Nombre ( "Jaime" );
Runnable n2 = new Nombre ( " Lola" );
Thread t1 = new Thread(n1); t1.start();
Thread t2 = new Thread(n2); t2.start();
}
}
Thread principal
Thread Jaime
Thread Lola
$ java Prueba
1177438860272: Lola
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Jaime
1177438860272: Jaime
1177438860272: Jaime
1177438860272: Jaime
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime
1177438860272: Lola
1177438860272: Jaime

Implementando la interfaz Runnable
¿Cuándo implementar la interfaz Runnable en lugar
de extender la clase Thread?
• Cuando una clase hereda de otra: no podría heredar también
de Thread
• Cuando no queremos heredar todos los métodos de la clase
Thread
• Cuando queremos diseñar el programa sin tener en cuenta la
concurrencia, y posteriormente queremos añadir
concurrencia
A pesar de no heredar de Thread podemos invocar
métodos de instancia de la clase Thread:
• Thread.currentThread() devuelve el thread actual
Ej. Thread.currentThread().getName()

Thread.sleep()
El método Thread.sleep() es un método estático
de la clase Thread: suspende la ejecución del thread
que lo ejecuta durante el número de milisegundos
especificado
Thread.sleep () tiene una cláusula throws
InterruptedException, pero run() no, por lo que
hay que tratar la excepción
La ejecución del bucle while no es muy precisa en
cuanto al periodo

Thread.sleep()
public class Nombre extends Thread {
int periodo;
public Nombre ( String nombre, int periodo ){
super( nombre );
this.periodo = periodo;
}
public void run() {
while( true ) {
System.out.println
(System.currentTimeMillis() + ": " + getName());
try { Thread.sleep ( periodo ); }
catch (InterruptedException e) {return ;}
}
}
}
public class Prueba {
public static void main( String[] args ) {
Nombre n1 = new Nombre ( "Jaime”, 500 );
Nombre n2 = new Nombre ( " Lola”, 100 );
n1.start();
n2.start();
}
}
Thread principal
Thread Jaime
Thread Lola
$ java Prueba
1177448963165: Jaime
1177448963165: Lola
1177448963265: Lola
1177448963366: Lola
1177448963466: Lola
1177448963566: Lola
1177448963665: Jaime
1177448963667: Lola
1177448963767: Lola
1177448963867: Lola
1177448963967: Lola
1177448964068: Lola
1177448964166: Jaime
1177448964168: Lola
1177448964268: Lola
1177448964369: Lola
1177448964469: Lola
1177448964569: Lola

Condiciones de carrera
El siguiente programa tiene condiciones de carrera
que no siempre se manifiestan cuando se ejecuta
Los 2 threads que crea el programa principal
comparten la misma instancia de la clase Hucha
El comportamiento deseable es que todas las veces
que se llame al método mete() queden reflejadas en
el estado de la variable ahorros de la hucha
• Sin embargo no siempre se obtiene este resultado, como se
ve en las ejecuciones del programa

Ejemplo simple
public class Pila {
}
int idx = 0;
char [] data = new char[6];
public void poner(char c) {
}
data[idx] = c;
idx++;
public char quitar() {
}
idx--;
return data[idx];

Ejemplo
El problema con el ejemplo anterior se reproduce
cuando dos o más hilos acceden a los métodos poner
y quitar de forma descontrolada.
Debemos evitar que mientras un hilo intenta poner
(quitar) el otro realice una operación que altere los
datos.
public class Pila {
...
...
}
public void poner(char c) {
}
synchronized (this) {
data[idx] = c;
idx++;
}

public class Hucha {
private int ahorros = 0;
public void mete ( int cantidad ) {
ahorros = ahorros + cantidad;
}
public int ahorros () { return ahorros; }
}
public class Ahorrador extends Thread {
Hucha hucha;
int iteraciones;
public Ahorrador ( String nombre, Hucha hucha, int iteraciones ) {
super (nombre);
this.hucha = hucha;
this.iteraciones = iteraciones;
}
public void run () {
for (int i=1; i

$ java PruebaAhorradores 10
Ahorros tras Pedro: 10
Ahorros tras Juan : 20
$ java PruebaAhorradores 100
Ahorros tras Pedro: 100
Ahorros tras Juan : 200
$ java PruebaAhorradores 1000
Ahorros tras Pedro: 1000
Ahorros tras Juan : 2000
$ java PruebaAhorradores 1000
Ahorros tras Pedro: 1497
Ahorros tras Juan : 1995
$ java PruebaAhorradores 100000
Ahorros tras Pedro: 100347
Ahorros tras Juan : 184980
$ java PruebaAhorradores 100000
Ahorros tras Juan : 86727
Ahorros tras Pedro: 171360
$ java PruebaAhorradores 100000
Ahorros tras Juan : 104166
Ahorros tras Pedro: 188799
Parece que funciona pero…
Parece que funciona pero…
Parece que funciona pero…
… NO funciona: hay condiciones de carrera
… NO funciona: hay condiciones de carrera
… NO funciona: hay condiciones de carrera
… NO funciona : hay condiciones de carrera

Condiciones de carrera
¡ La sentencia de asignación NO se ejecuta de manera atómica !
public class Hucha {
private int ahorros = 0;
public void mete ( int cantidad ) {
ahorros = ahorros + cantidad;
}
public int ahorros () { return ahorros; }
}
13 MOVE ahorros, A
14 ADD A, cantidad
15 MOVE A, ahorros
Thread Pedro
Thread Juan
A cantidad PC ahorros
0 1 13 0
A cantidad PC ahorros
0 1 13 0
A cantidad PC ahorros
1 1 14 0
A cantidad PC ahorros
1 1 15 1
A cantidad PC ahorros
0 1 13 1
A cantidad PC ahorros
1 1 14 1
A cantidad PC ahorros
1 1 15 1

Sincronización y comunicación de threads
Los threads en Java se comunican y sincronizan llamando a métodos
marcados como synchronized, pertenecientes a otros objetos
Un objeto con uno o más métodos synchronized tiene un lock
interno (es un mutex, y sólo hay uno por objeto)
• Si un thread llama a un método synchronized de un objeto que no
está bloqueado, puede continuar, bloqueándose atómicamente el objeto
mientras dura la ejecución del método synchronized
• Si un thread llama a un método synchronized de un objeto
bloqueado por otro thread, se suspende la ejecución del thread
llamante hasta que el objeto se desbloquee

public class Hucha {
private int ahorros = 0;
public synchronized void mete ( int cantidad ) {
ahorros = ahorros + cantidad;
}
public synchronized int ahorros () { return ahorros; }
}
public class Ahorrador extends Thread {
Hucha hucha;
int iteraciones;
public Ahorrador ( String nombre, Hucha hucha, int iteraciones ) {
super (nombre);
this.hucha = hucha;
this.iteraciones = iteraciones;
}
public void run () {
for (int i=1; i

$ java PruebaAhorradores 10
Ahorros tras Pedro: 10
Ahorros tras Juan : 20
$ java PruebaAhorradores 100
Ahorros tras Pedro: 100
Ahorros tras Juan : 200
$ java PruebaAhorradores 1000
Ahorros tras Pedro: 1292
Ahorros tras Juan : 2000
$ java PruebaAhorradores 1000
Ahorros tras Pedro: 1499
Ahorros tras Juan : 2000
$ java PruebaAhorradores 100000
Ahorros tras Pedro: 194544
Ahorros tras Juan : 200000
$ java PruebaAhorradores 100000
Ahorros tras Juan : 191417
Ahorros tras Pedro: 200000
$ java PruebaAhorradores 100000
Ahorros tras Juan : 197544
Ahorros tras Pedro: 200000

Sincronización y comunicación de threads
Mediante llamadas a wait(), notify() y notifyAll()
desde dentro de métodos synchronized se puede suspender o
desuspender la ejecución de métodos en función del estado del
objeto

public class Hucha {
private int ahorros = 0; private final int MAXIMO = 10;
public synchronized void mete (int cantidad) {
while (ahorros + cantidad > MAXIMO)
try {wait();} catch (InterruptedException e) {return;};;
ahorros = ahorros + cantidad;
notifyAll(); // Despertamos a los gastadores, y al resto
}
public synchronized void saca (int cantidad) {
while (ahorros < cantidad)
try {wait();} catch (InterruptedException e) {return;};
ahorros = ahorros - cantidad;
notifyAll(); // Despertamos a los ahorradores, y al resto
}
public synchronized int ahorros () { return ahorros; }
}
public class Gastador extends Thread {
Hucha hucha; int iteraciones;
public Gastador
( String nombre, Hucha hucha, int iteraciones ) {
super (nombre);
this.hucha = hucha;
this.iteraciones = iteraciones;
}
public void run () {
for (int i=1; i

$ java PruebaAhorradores 1000 1000 2000
Ahorros tras ahorrador 1: 7
Ahorros tras ahorrador 2: 6
Ahorros tras gastador 1 : 0
$ java PruebaAhorradores 5 5 10
Ahorros tras ahorrador 1: 5
Ahorros tras gastador 1 : 0
Ahorros tras ahorrador 2: 10
$ java PruebaAhorradores 100 100 200
Ahorros tras ahorrador 2: 0
Ahorros tras gastador 1 : 0
Ahorros tras ahorrador 1: 0
$ java PruebaAhorradores 100 100 500
Ahorros tras ahorrador 1: 4
Ahorros tras ahorrador 2: 7
^C
$ java PruebaAhorradores 50 50 90
Ahorros tras ahorrador 1: 5
Ahorros tras gastador 1 : 1
Ahorros tras ahorrador 2: 10
$ java PruebaAhorradores 50 50 70
Ahorros tras ahorrador 1: 10
Ahorros tras gastador 1 : 10
^C
26

Clases e interfaces en java.lang
Interfaz Runnable
public interface Runnable {
void run();
}
Métodos relacionados con threads
de la clase Object
public class Object {
public final void wait() throws InterruptedException;
public final native void wait(long timeout)
throws InterruptedException;
public final void wait(long timeout, int nanos)
throws InterruptedException;
public final native void notify();
public final native void notifyAll();
}
Clase Thread
public class Thread implements Runnable {
public final static int MIN_PRIORITY = 1;
public final static int MAX_PRIORITY = 10;
public final static int NORM_PRIORITY = 5;
public Thread();
public Thread(String name);
public Thread(Runnable runObject);
public Thread(Runnable runObject, String name);
public String toString();
public void run();
public final void start()
throws IllegalThreadStateException;
public final void stop() throws SecurityException;
public final void suspedn() throws SecurityException;
public final void resume() throws SecurityException;
public final String getName();
public final int getPriority();
public final int setPriority(int newPriority)
throws SecurityException, IllegalArgumentException;
public final void join() throws InterruptedException;
public final void join(long millis)
throws InterruptedException;
public void interrupt();
public boolean isInterrupted();
}
public static Thread currentThread();
public static void yield();
public static void sleep( long millis )
throws InterruptedException;
public void destroy();

Otros
Yield()
• Avisa al scheduler que puede interrumpir el thread. Es útil
en algunos casos, pero no suele ser fiable.
// Suggesting when to switch threads with yield().
public class YieldingThread extends Thread {
private static Test monitor = new Test();
private int countDown = 5;
private static int threadCount = 0;
public YieldingThread() {
super("" + ++threadCount);
start();
}
public String toString() {
return "#" + getName() + ": " + countDown;
}
public void run() {
while(true) {
System.out.println(this);
if(--countDown == 0) return;
yield();
}
}
public static void main(String[] args) {
for(int i = 0; i < 5; i++)
new YieldingThread();
}
} //

Otros
Join()
• Hace que el thread espere a que otro thread haya
terminado.
// Understanding join().
class Sleeper extends Thread {
private int duration;
public Sleeper(String name, int sleepTime) {
super(name);
duration = sleepTime;
start();
}
public void run() {
try {
sleep(duration);
} catch (InterruptedException e) {
System.out.println(getName() + " was interrupted. " +
"isInterrupted(): " + isInterrupted());
return;
}
System.out.println(getName() + " has awakened");
}
}
class Joiner extends Thread {
private Sleeper sleeper;
public Joiner(String name, Sleeper sleeper) {
super(name);
this.sleeper = sleeper;
start();
}
public void run() {
try {
sleeper.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(getName() + " join completed");
}
}

Join
public class Joining {
private static Test monitor = new Test();
public static void main(String[] args) {
Sleeper
sleepy = new Sleeper("Sleepy", 1500),
grumpy = new Sleeper("Grumpy", 1500);
Joiner
dopey = new Joiner("Dopey", sleepy),
doc = new Joiner("Doc", grumpy);
grumpy.interrupt();
}
} /

Sectiones Críticas
Un synchronized sobre un objeto:
• Sirven para crear regiones críticas. Por ejemplo:
synchronized(syncObject) {
}
// This code can be accessed
// by only one thread at a time

Wait and notify
Se pueden utilizar sobre un objeto sincronizado.
class Order {
private static int i = 0;
private int count = i++;
public Order() {
if(count == 10) {
System.out.println("Out of food, closing");
System.exit(0);
}
}
public String toString() { return "Order " + count; }
}
class WaitPerson extends Thread {
private Restaurant restaurant;
public WaitPerson(Restaurant r) {
restaurant = r;
start();
}
public void run() {
while(true) {
while(restaurant.order == null)
synchronized(this) {
try {
wait();
} catch(InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println(
"Waitperson got " + restaurant.order);
restaurant.order = null;
}
}
}
class Chef extends Thread {
private Restaurant restaurant;
private WaitPerson waitPerson;
public Chef(Restaurant r, WaitPerson w) {
restaurant = r;
waitPerson = w;
start();
}
public void run() {
while(true) {
if(restaurant.order == null) {
restaurant.order = new Order();
System.out.print("Order up! ");
synchronized(waitPerson) {
waitPerson.notify();
}
}
try {
sleep(100);
} catch(InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
public class Restaurant {
private static Test monitor = new Test();
Order order; // Package access
public static void main(String args[]) {
Restaurant restaurant = new Restaurant();
WaitPerson waitPerson = new WaitPerson(restaurant);
Chef chef = new Chef(restaurant, waitPerson);
}
} ///:~