031 Threads

Click here to load reader

  • date post

    27-Sep-2015
  • Category

    Documents

  • view

    247
  • download

    0

Embed Size (px)

description

Manual hilos java

Transcript of 031 Threads

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