Anlisis y diseo de software

dit
UPM

Tema 3: Concurrencia
/threads
Jos A. Maas
http://jungla.dit.upm.es/~pepe/doc/adsw/index.html

11.3.2013

referencias
http://jungla.dit.upm.es/~pepe/
doc/adsw/
libros/concurrency/index.html

The Java tutorials: Concurrency

http://docs.oracle.com/javase/tutorial/
essential/concurrency/

Java Concurrency in Practice

B. Goetz et al.
Addison-Wesley, 2006
concurrencia

ndice
concurrencia
modelo java: 1 RAM + N aplicaciones ligeras

Theads

clases Thread & Runnable

arrancar threads
parar threads
varios

propiedades de la concurrencia

correccin (correctness)
seguridad (safety)
vivacidad (liveness)
equidad (fairness)

concurrencia

programacin
programas concurrentes
describen varias actividades que podran
progresar al mismo tiempo
el flujo de ejecucin admite muchas opciones

programas secuenciales
describen 1 actividad
slo hay 1 flujo de ejecucin:
seguir la secuencia de sentencias

concurrencia

concurrencia
se dice que N tareas ejecutan concurrentemente
cuando se reparten el tiempo y/o la CPU para ir
ejecutando
con 1 CPU, la concurrencia es simulada
un ratito la CPU para mi, un ratito para ti
T1

T2

T2

T1

T2

T1

T1

T2

T2

con varias CPUs, parte es paralelismo real,

parte es paralelismo simulado repartiendo t
concurrencia

para qu?
para aprovechar mejor las CPUs
para poder dejar una tarea esperando algo
mientras otras pueden ir progresando
ej. interfaces de usuario reactivas
(siempre estn dispuestas)
ej. servidores con varios clientes (ej. www)
ej. sistemas de control industrial

porque la solucin natural es concurrente

porque el mundo real es concurrente
concurrencia

implicaciones
concurrencia implica
competencia
por los recursos comunes

sincronizacin
para coordinar actividades

cooperacin
para intercambiar informacin

ejemplo:
2 amigos preparando la comida
trenes
concurrencia

java: threads
tareas ligeras
memoria RAM comn
con las reglas de visibilidad de java
private, de paquete, pblicas
variables de objeto
(privadas)

variables de objeto
(visibles)

variables de clase (compartidas)

cdigo (read only)
concurrencia

memoria
la memoria comn
bueno: es muy eficiente cambiar de thread:
ligeros
bueno: es muy fcil compartir datos entre threads
malo: es muy fcil que un thread corrompa los
datos de otro

concurrencia

memoria: variables locales

cada thread tiene sus variables locales
parmetros o argumentos de mtodos
variables creadas dentro de los mtodos
en principio son privadas;
pero puede haber comparticin si se pasan
referencias

concurrencia

10

memoria compartida: carreras

carreras (race conditions)
1.
2.
3.
4.
5.

concurrencia

yo me traigo el dato a mi memoria local

tu te llevas el dato a tu memoria local
modificamos nuestros datos
yo lo devuelvo, tu lo devuelves
quin tiene la ltima palabra?

11

cmo crear threads?

opcin 1:
class MiTarea extends Thread {
public void run() { ... }
MiTarea t1 = new MiTarea();

opcin 2:
class MR implements Runnable {
public void run() { ... }
Thread t1 = new Thread(new MR());

concurrencia

12

ejemplo: implements Runnable

public class RelojTipo1
implements Runnable {
private final String id;
private final int dt;
public RelojTipo1(String id, int dt) {
this.id = id;
this.dt = dt;
}

public void run() {

try {
while (true) {
System.out.println(id + ": " + new Date());
Thread.sleep(dt * 1000);
}
} catch (InterruptedException e) {
System.out.println(id + ": muerto soy.");
}
}
}

concurrencia

13

ejemplo: extends Thread

public class RelojTipo2
extends Thread {
private final String id;
private final int dt;
public RelojTipo2(String id, int dt) {
this.id = id;
this.dt = dt;
}

concurrencia

@Override
public void run() {
try {
while (true) {
System.out.println(id + ": " + new Date());
Thread.sleep(dt * 1000);
}
} catch (InterruptedException e) {
System.out.println(id + ": muerto soy.");
}
}
}

14

ejemplo:
public class RelojTipo3 implements Runnable {
private final String id;
private final BufferedReader console;
public RelojTipo3(String id) {
this.id = id;
console = new BufferedReader(new InputStreamReader(System.in));
}

concurrencia

public void run() {

try {
while (true) {
String line = console.readLine();
if (line.equals(".")) break;
System.out.printf("%s: %s: %s%n", new Date(), id, line);
}
System.out.println(id + ": muerto soy.");
} catch (IOException e) {
System.out.println(id + ": " + e);
}
15
}

ejemplo: uso
Thread A1 = new Thread(new RelojTipo1("A1", 3));
Thread A2 = new Thread(new RelojTipo1("A2", 5));
Thread B1 = new RelojTipo2("B1", 7);
Thread B2 = new RelojTipo2("B1", 11);
Thread C = new Thread(new RelojTipo3("C"));
A1.start();
A2.start();
B1.start();
B2.start();
C.start();

Thread.sleep(30 * 1000);
A1.interrupt();
concurrencia

16

interrupciones
desde fuera
void interrupt()
marca en estado interrupted

dentro
static boolean interrupted()
devuelve T | F y elimina el estado (1 vez)

boolean isInterrupted()
devuelve T | F

concurrencia

17

uso interno de interrupted

muchas operaciones de espera pueden verse interrumpidas
try {
Thread.sleep(s * 1000);
} catch (InterruptedException e) {
// habr que hacer algo
}

otra opcin es chequear cuando nos venga bien

if (isInterrupted()) {
// habr que hacer algo
}
concurrencia

18

cundo termina un thread?

cuando termina el mtodo run()
public class Tarea extends Thread {
private volatile boolean funcionando = true;
@Override
public void run() {
while (funcionando) {

}
}

public void parar() {

this.funcionando = false;
}
}
concurrencia

19

volatil
algunos campos pueden declararse
volatil

con esto se le dice a la mquina virtual java

esa variable puede cambiar
en cualquier momento
no la metas en tu memoria privada
(por ejemplo, en la cach de la CPU)

concurrencia

20

otros mtodos tiles

sleep(long ms)
prate un ratito

setName(String name)
aparecer con el toString()
tambin: new Thread(String name)

void yield()
querida tarea, por favor, deja que ejecuten las dems
java hace lo que le da la gana
(depende del sistema operativo)

void join()
espero a que termine
concurrencia

21

estado
Thread.State getState()

no se puede
volver a arrancar
una tarea terminada
concurrencia

22

prioridad
int getPriority()
void setPriority(int n)
MIN_PRIORITY .. MAX_PRIORITY
mayor prioridad ms CPU

concurrencia

23

mtodos que NO se deben usar

stop()
suspend()
resume()
lo suyo es controlar con campos
lo que hace run()
veremos sincronizadores para detener una
tarea hasta que se de una condicin
concurrencia

24

cuntas threads?
el programa principal
+ las tareas que arrancamos
(hasta que terminen)
+ lo que se le ocurre al IDE
Set<Thread> threadSet =
Thread.getAllStackTraces().keySet();
for (Thread thread : threadSet)
System.out.println(thread);

concurrencia

25

propiedades
correccin (correctness)
da el resultado correcto

seguridad (safety)
no pasa nada malo

vivacidad (liveness)
en algn momento hace lo que se espera

equidad (fairness)
las threads se reparten la CPU con justicia
concurrencia

26

correccin
se genera el resultado correcto
se puede usar JUnit
pruebas unitarias
assertEquals(esperado, obtenido)

OJO debe generar SIEMPRE el resultado

correcto
problema: indeterminismo:
a veces s, a veces no
concurrencia

27

seguridad - safety
nothing bad ever happens
nunca funciona mal
cosas que pueden ir mal
carreras valores incorrectos

concurrencia

28

vivacidad - livenesss
something good eventually happens
en algn momento hace lo correcto
cosas que pueden ir mal
deadlock interbloqueo
el programa se queda muerto

livelock bloqueo activo

el programa da vueltas y vueltas sin sentido
crculo vicioso
concurrencia

29

equidad - fairness
los recursos se reparten con justicia
lo contrario
inanicin starvation
a alguna thread nunca se le da oportunidad

concurrencia

30

pruebas
es muy difcil hacer pruebas de las
propiedades
a veces se consigue demostrar usando tcnicas
matemticas
demostracin de teoremas
anlisis de todas las ejecuciones posibles

recomendacin
programar de forma muy bien estructurada para
asegurarnos de que no hay malas combinaciones
concurrencia

31