1 / 62

Programación Concurrente en Java

Programación Concurrente en Java. Métodos sincronizados Monitores y condiciones. Programación Concurrente ETSI Informática-UMA M.M. Gallardo. Métodos Sincronizados. Cada objeto Java tiene asociado un lock (cerrojo).

tracy
Download Presentation

Programación Concurrente en Java

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Programación Concurrente en Java Métodos sincronizados Monitores y condiciones Programación Concurrente ETSI Informática-UMA M.M. Gallardo

  2. Métodos Sincronizados • Cada objeto Java tiene asociado un lock (cerrojo). • La palabra synchronized puede utilizarse para señalar aquellos métodos del objeto que deben ejecutarse en exclusión mutua. • Antes de ejecutar un método sincronizado hay que competir para conseguir el lock del objeto al que pertenece.

  3. Ejemplo: Problema de los jardines public class Cont { private int c = 0; public synchronized void inc(int i){ c++; } public synchronized int valor(){ return c; } } La ejecución de inc se realiza en exclusión mutua

  4. Ejemplo: Problema de los jardines public class puerta implements Runnable{ Cont c; public jardin(Cont c){this.c = c;} public void run(){ for (int i = 0; i<20; i++) c.inc(1); } } La ejecución de inc se realiza en exclusión mutua

  5. Ejemplo: Problema de los jardines public class UsaJardines { public static void main(String[] args){ final int N = 10; Cont c = new Cont(); puerta[] p = new puerta[N]; for (int i = 0; i< N; i++) p[i] = new puerta(c); Thread[] ph = new Thread[N]; for (int i = 0; i< N; i++) ph[i] = new Thread(p[i]); for (int i = 0; i< N; i++) ph[i].start(); for (int i = 0; i< N; i++) try{ph[i].join(); }catch (InterruptedException e){} System.out.println(c.valor()); } } Todas las hebras compiten

  6. Mecanismo de entrada/salida al Monitor

  7. Java no asigna ninguna estructura concreta a las hebras que están en el conjunto de entrada. La implementación podría usar • Una FIFO • Una LIFO • Una FIFO basada en prioridades

  8. Condiciones de sincronización Cuando una hebra que tiene el lock de un objeto y debe suspenderse debido a alguna condición de sincronización, se introduce en el conjunto de espera del objeto, llamando al método void wait() Cuando una hebra ejecuta wait(): - Libera el lock del objeto sincronizado - Se bloquea en el conjunto de espera

  9. Mecanismo de entrada/salida revisado

  10. Disciplina del Monitor Los métodos void notify(), void notifiyAll() despiertan a una/todas las hebras del conjunto de espera. Java utiliza la disciplina notify-and-continue, es decir, la hebra que hace notify continúa con el lock del monitor. Por lo tanto, la hebra que espera debe ejecutar un código del tipo: while (!condicion) try {wait(); } catch (Exception e){}

  11. Métodos sincronizados:Productor/Consumidor public class Buffer { private int[] b; private int tam; private int i=0; private int j=0; private int numDatos = 0; public Buffer(int t){ tam = t; b = new int[tam]; } ........... }

  12. Métodos sincronizados:Productor/Consumidor ..... public synchronized void poner(int d) throws InterruptedException{ while (numDatos == tam) wait(); b[i] = d; i = (i + 1) % tam; numDatos++; notify(); } public synchronized int extraer() throws InterruptedException{ while (numDatos == 0) wait(); int aux = j; j = (j + 1) % tam; numDatos--; notify(); return b[aux]; } } mientras el buffer está lleno/vacío esperar

  13. Métodos sincronizados:Productor/Consumidor ..... public synchronized void poner(int d) throws InterruptedException{ while (numDatos == tam) wait(); b[i] = d; i = (i + 1) % tam; numDatos++; notify(); } public synchronized int extraer() throws InterruptedException{ while (numDatos == 0) wait(); int aux = j; j = (j + 1) % tam; numDatos--; notify(); return b[aux]; } } Cambia el estado del buffer y aviso a la otra hebra, por si acaso

  14. Métodos sincronizados: conjunto de espera único • Cuando se utilizan métodos sincronizados hay sólo un conjunto de espera, en el que pueden estar suspendidas hebras que esperan que diferentes condiciones de sincronización sean ciertas. • Cuando una hebra ejecuta notify, puede ser que no despierte a la hebra adecuada, por lo que habrá que programar un despertado en cascada o utilizar el método notifyAll().

  15. Múltiples productores y consumidores Condiciones de sincronización Hay varios procesos productores y consumidores. Todos los procesos utilizan el buffer en exclusión mutua. Un productor no puede escribir hasta que no hay sitio en el buffer. Los consumidores leen todos los datos producidos, En el mismo orden. Si el buffer está vacío esperan.

  16. Múltiples productores y consumidores -suponiendo 1 productor y 3 consumidores numDatos = 3 j b f k M Z A 2 3 0 0 1 0 0 0 flect 2 3 5 c Índice para cada consumidor

  17. Múltiples productores y consumidores -si el consumidor 2 consume numDatos = 3 j b f k M Z A 2 3 0 0 1 flect 0 0 0 fcons 2 3 4 c 3 2 0 Índice para cada consumidor Ya no puede consumir más

  18. Múltiples productores y consumidores -si el consumidor 0 consume numDatos = 2 j b f k M Z A 0 2 3 0 0 flect 0 0 0 fcons 3 3 4 c 2 2 0 Índice para cada consumidor Deja un hueco libre para el productor

  19. Múltiples productores y consumidores -si el productor produce numDatos = 3 j b H f k M Z A 0 2 3 0 0 flect 3 0 0 fcons 3 3 4 c 3 3 1 Índice para cada consumidor Indica a todos que pueden Consumir un dato más

  20. Múltiples productores y consumidores package multProdCons; public class Buffer { private int[] b; // buffer private int[] c; // indice de cada consumidor private int[] fdatos; // para cada consumidor, los datos que le quedan por leer private int[] flect; // para cada dato, las lecturas que le quedan private int tam; private int i=0; private int j=0; private int numDatos = 0; private int nlectores = 0; ................. }

  21. Múltiples productores y consumidores public Buffer(int t,int nlectores){ tam = t; b = new int[tam]; c = new int[tam]; for (int i=0;i<tam;i++) c[i] = 0; this.nlectores = nlectores; fdatos = new int[nlectores]; for (int i=0;i<nlectores;i++) fdatos[i] = 0; flect = new int[tam]; for (int i = 0; i < tam ; i++) flect[i] = 0; System.out.println("buffer inicializado"); }

  22. Múltiples productores y consumidores public synchronized void poner(int id,int d) throws InterruptedException{ while (numDatos == tam) {notify(); wait();} b[i] = d; for (int c = 0; c < nlectores ; c++) fdatos[c]++; flect[i] = nlectores; i = (i + 1) % tam; numDatos++; notify(); } En la sala de espera hay procesos productores y consumidores. Cuando se despierta una hebra, puede ser que tenga que seguir esperando.... Desperado en cascada

  23. Múltiples productores y consumidores public synchronized int extraer(int id) throws InterruptedException{ while (fdatos[id] == 0) {notify(); wait();} int aux = c[id]; fdatos[id]--; flect[c[id]]--; if (flect[c[id]] == 0) {numDatos--; notify();} c[id] = (c[id] + 1) % tam; return b[aux]; } Como en el caso de los productores Desperado en cascada

  24. Múltiples productores y consumidores public class Consumidor implements Runnable{ Buffer b; int id; public Consumidor(Buffer b, int id){ this.b = b; this.id = id; } public void run(){ int d = 0; System.out.println("comienza consumidor"); for (int i=0;i<10;i++){ try{d = b.extraer(id); } catch (Exception e){}; System.out.println("Consumidor " + d); } } }

  25. Múltiples productores y consumidores public class Productor implements Runnable{ Buffer b; int id; public Productor(Buffer b,int id){ this.b = b; this.id = id; } public void run(){ System.out.println("comienza productor"); for (int i = 0; i<10; i++){ try {b.poner(id,i); } catch (Exception e){}; System.out.println("Productor "+i); } } }

  26. Múltiples productores y consumidores public class UsaProdCons { public static void main(String[] args){ final int numCons = 5; Buffer b = new Buffer(5,numCons); Productor p = new Productor(b,1); Consumidor[] c = new Consumidor[numCons]; for (int i = 0; i<numCons; i++) c[i] = new Consumidor(b,i); System.out.println("comienza el programa"); Thread ph = new Thread(p); Thread[] ch = new Thread[numCons]; for (int i = 0; i<numCons; i++) ch[i] = new Thread(c[i]); for (int i = 0; i<numCons; i++) ch[i].start(); ph.start(); } }

  27. Múltiples productores y consumidores con notifyAll public synchronized void poner(int id,int d) throws InterruptedException{ System.out.println("productor " + id + "quiere poner "+d); while (numDatos == tam) { wait();} System.out.println("productor "+ id + " escribe en el buffer"); b[i] = d; for (int c = 0; c < nlectores ; c++) fdatos[c]++; flect[i] = nlectores; i = (i + 1) % tam; numDatos++; notifyAll(); } Hay un nuevo dato y aviso a todos

  28. Lectores/Escritores (v. injusta) public class ControlBD { private int nLectores = 0; private boolean escribiendo = false; public synchronized void OpenL(int i) throws Exception{ while (escribiendo) wait(); nLectores++; System.out.println("Entra lector "+i); } public synchronized void OpenE(int i) throws Exception{ while (escribiendo || (nLectores > 0)) wait(); escribiendo = true; System.out.println("Entra escritor "+i); } ......

  29. Lectores/Escritores (v. injusta) public synchronized void CloseL(int i) throws Exception{ nLectores--; if (nLectores == 0) notifyAll(); System.out.println("Sale lector "+i); } public synchronized void CloseE(int i) throws Exception{ escribiendo = false; notifyAll(); System.out.println("Sale escritor "+i); } }

  30. Lectores/Escritores (v. injusta) public class Escritor implements Runnable{ int miId; ControlBD c; public Escritor(int id,ControlBD c){ miId = id; this.c = c; } public void run(){ for (int i = 0; i < 10; i++){ try{ c.OpenE(miId); Thread.sleep(1); c.CloseE(miId); } catch (Exception e){}; } } }

  31. Lectores/Escritores (v. injusta) public class Lector implements Runnable{ int miId; ControlBD c; public Lector(int id,ControlBD c){ miId = id;this.c = c; } public void run(){ for (int i = 0; i < 10; i++){ try{ c.OpenL(miId); Thread.sleep(1); c.CloseL(miId); } catch (Exception e){}; } } }

  32. Lectores/Escritores • El tener solo una cola de espera puede ser ineficiente si despertamos a procesos que no pueden continuar su ejecución porque todavía no se satisface la condición por la que esperan.

  33. Lectores/Escritores (v. justa) public class ControlBD { private int nLectores = 0; private boolean escribiendo = false; private int nEscritores = 0; public synchronized void OpenL(int i) throws Exception{ while (escribiendo || (nEscritores > 0)) { System.out.println("Lector quiere entrar "+i); wait(); } nLectores++; } ..............

  34. Lectores/Escritores (v. justa) public synchronized void OpenE(int i) throws Exception{ nEscritores++; while (escribiendo || (nLectores > 0)) { System.out.println("Escritor quiere entrar "+i); wait(); } escribiendo = true; }

  35. Lectores/Escritores (v. justa) public synchronized void CloseL(int i) throws Exception{ nLectores--; if (nLectores == 0) notifyAll(); } public synchronized void CloseE(int i) throws Exception{ nEscritores--; escribiendo = false; notifyAll(); } } Despierta a todos

  36. Lectores/Escritores (v. justa) public synchronized void CloseL(int i) throws Exception{ nLectores--; if (nLectores == 0) notifyAll(); } public synchronized void CloseE(int i) throws Exception{ nEscritores--; escribiendo = false; notifyAll(); } } Despierta a todos

  37. Lectores/Escritores (v. justa) comienza Lectores/Escritores Escritor quiere entrar 0 Escritor quiere entrar 1 Lector quiere entrar 0 Lector quiere entrar 1 Lector quiere entrar 2 Lector quiere entrar 3 Lector quiere entrar 4 Lector quiere entrar 5 Lector quiere entrar 6 Lector quiere entrar 7 Lector quiere entrar 8 Lector quiere entrar 9 Lector quiere entrar 10 Lector quiere entrar 11 Lector quiere entrar 12 Lector quiere entrar 13 Escritor quiere entrar 1 Lector quiere entrar 0 Lector quiere entrar 1 Lector quiere entrar 2 Lector quiere entrar 3 Lector quiere entrar 4 Lector quiere entrar 6 ................................... Hasta 350 intentos fallidos para 15 Lectores y 2 Escritores

  38. Hebra h class Ejemplo{ public synchronized void p(){ .......... } } Llamadas anidadas a métodos sincronizados Para que h ejecute e.p(), debe obtener el lock de e Ejemplo e = --- e.p()

  39. Hebra h tiene lock(e) class Ejemplo2{ public synchronized void p(){ .......... } } class Ejemplo{ public synchronized void p(){ .......... } } Llamadas anidadas a métodos sincronizados Ejemplo2 e1 = .... Ejemplo e = --- e.p() e1.p() Para que e ejecute e1.p() debe obtener el lock de e1

  40. Hebra h tiene lock(e), lock(e1) class Ejemplo2{ public synchronized void p(){ .......... } } class Ejemplo{ public synchronized void p(){ .......... } } Llamadas anidadas a métodos sincronizados Ejemplo2 e1 = .... Ejemplo e = --- e.p() e1.p()

  41. Hebra h tiene lock(e) class Ejemplo{ public synchronized void p(){ .......... } } class Ejemplo2{ public synchronized void p(){ .......... wait() } } Llamadas anidadas a métodos sincronizados Ejemplo2 e1 = .... Ejemplo e = --- e.p() e1.p() Si se ejecuta wait(), se libera el lock de e1, pero se mantiene el de e, lo que puede producir bloqueos

  42. Productor/Consumidor con condiciones y bloqueo public class Condition { public synchronized void delay(){ try{wait(); // suspende a la hebra que lo ejecuta }catch (Exception e){}; } public synchronized void resume(){ try{notify(); // despierta una hebra suspendida }catch (Exception e){}; } }

  43. Productor/Consumidor con condiciones y bloqueo public class Buffer { private int[] b; private int tam; private int i=0; private int j=0; private int numDatos = 0; private final Condition nolleno = new Condition(); private final Condition novacio = new Condition(); public Buffer(int t){ tam = t; b = new int[tam]; } ....... }

  44. Productor/Consumidor con condiciones y bloqueo public synchronized void poner(int d) throws InterruptedException{ while (numDatos == tam) nolleno.delay(); b[i] = d; i = (i + 1) % tam; numDatos++; novacio.resume(); } public synchronized int extraer() throws InterruptedException{ while (numDatos == 0) novacio.delay(); int aux = j; j = (j + 1) % tam; numDatos--; nolleno.resume(); return b[aux]; } Bloquea a la hebra Buffer Bloquea a la hebra Buffer

  45. Locks Los métodos/instrucciones synchronized modelan el acceso exclusivo a lock de un monitor implícito asociado a un objeto, típicamente un recurso compartido por varias hebras. Sin embargo, cuando una hebra necesita usar más de un recurso, debe liberar los locks de los recursos en orden inverso a como se han obtenido, lo que en ocasiones puede no ser adecuado .... A.acquire(); B.acquire(); C.acquire(); A.release(); D.acquire(); B.release(); ......

  46. Locks public class ReentrantLock ReentrantLock l = new ReentrantLock(); Un Lock para la exclusión mutua con la misma semántica y comportamiento que el lock implícito tipo monitor de los métodos e instrucciones sincronizadas (synchronized), pero con más posibilidades.

  47. Locks: el problema de los jardines Implementación de la interfaz lock public class Cont { Lock l = new ReentrantLock(); private int c = 0; public void inc(int i){ l.lock(); try{ c++; } finally { l.unlock(); } } Pido el lock Devuelvo el lock

  48. Locks: el problema de los jardines public int valor(){ l.lock(); try{ return c; } finally { l.unlock(); } } Pido el lock Devuelvo el lock La cláusula try/finally es necesaria para devolver el lock después de ejecutar return

  49. Locks: condiciones Para modelar las condiciones de sincronización usamos la Interfaz Condition. public interface Condition Las condiciones clasifican los métodos del monitor (wait, notify and notifyAll) en distintos objetos de forma que es posible tener múltiples conjuntos de espera por objeto, asociados a locks. Lock l = new ReentrantLock() Condition c1 = l.newCondition(); Condition c2 = l.newCondition(); Las condiciones se asocian a locks y pueden definirse tantas como sea necesario

  50. Locks: condiciones Métodos void await() throws InterruptedException Suspende a la hebra en la condición correspondiente void signal() Despierta una de las hebras que espera. La hebra tiene que conseguir el lock correspondiente antes de continuar su ejecución. (disciplina signal-and-continue) void signalAll() Desperta a todas las hebras que esperan. Cada hebra tiene que conseguir el lock correspondiente antes de continuar su ejecución. (disciplina signal-and-continue)

More Related