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 2

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 3

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 4

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

con varias CPUs, parte es paralelismo real, parte es paralelismo simulado repartiendo t

concurrencia 5

T1 T2 T2 T2 T2 T2 T1 T1 T1

t

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 6

implicaciones

concurrencia implica competencia

por los recursos comunes

sincronizacin para coordinar actividades

cooperacin para intercambiar informacin

ejemplo: 2 amigos preparando la comida

trenes

concurrencia 7

java: threads

tareas ligeras

memoria RAM comn

con las reglas de visibilidad de java

private, de paquete, pblicas

concurrencia 8

cdigo (read only)

variables de clase (compartidas)

variables de objeto (privadas)

variables de objeto (visibles)

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 9

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. yo me traigo el dato a mi memoria local

2. tu te llevas el dato a tu memoria local

3. modificamos nuestros datos

4. yo lo devuelvo, tu lo devuelves

5. quin tiene la ltima palabra?

concurrencia 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

concurrencia 13

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."); } } }

ejemplo: extends Thread

concurrencia 14

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; }

@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."); } } }

ejemplo:

concurrencia 15

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)); } 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); } }

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

concurrencia 18

try { Thread.sleep(s * 1000); } catch (InterruptedException e) { // habr que hacer algo }

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

muchas operaciones de espera pueden verse interrumpidas

otra opcin es chequear cuando nos venga bien

cundo termina un thread?

cuando termina el mtodo run()

concurrencia 19

public class Tarea extends Thread {

private volatile boolean funcionando = true;

@Override

public void run() {

while (funcionando) {

}

}

public void parar() {

this.funcionando = false;

}

}

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()

concurrencia 22

no se puede volver a arrancar una tarea terminada

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 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