Natalia Partera Jaime Alumna colaboradora de la asignatura

Transcripción

1 Programación Concurrente y de Tiempo Real Guión de prácticas 6: Programación en Java de algoritmos de control de la Exclusión Mutua con variables comunes Natalia Partera Jaime Alumna colaboradora de la asignatura

2 Índice 1. Introducción 2 2. Búsqueda de un algoritmo de control de la exclusión mutua Primer intento Segundo intento Tercer intento Cuarto intento Algoritmo de Dekker Variables volatile Ejercicios Soluciones de los ejercicios Ejercicio

3 1. Introducción A veces al ejecutar procesos concurrentemente, puede aparecer el problema de la exclusión mutua. Esto significa que varios de los procesos pueden pretender acceder a cierto recurso compartido a la misma vez. Para conseguir que los procesos trabajen como está previsto y aporten el resultado esperado, los ejecutaremos bajo la exclusión mutua controlada con variables comunes. Para garantizar el éxito del programa, sus procesos deben satisfacer la condición de exclusión mutua. Es decir, las instrucciones de cada proceso que hacen referencia al recurso crítico compartido (sección crítica) no deben ejecutarse entrelazadas. Por lo que es necesario controlar la exclusión mutua de los procesos. Para un número N de procesos, es necesario: Identificar y diferenciar, dentro de cada proceso, entre su sección crítica y el resto del código. Permitir que sólo un proceso pueda estar ejecutando su sección crítica a la vez. Para ello, cada proceso debe ejecutar un pre-protocolo antes de entrar en su sección crítica y un post-protocolo al salir. Las condiciones para resolver este tipo de problemas son las mismas sean 2 procesos los que intervengan o sean más. Tan sólo hay que adaptar el algoritmo al número de procesos que intervienen. Uno de los algoritmos que solucionan el problema de la exclusión mutua es el algoritmo de Dekker. A continuación, procedemos a explicarlo paso a paso. Para entenderlo mejor, lo explicaremos primero para 2 procesos. 2. Búsqueda de un algoritmo de control de la exclusión mutua Para buscar un algoritmo que controle la exclusión mutua, utilizaremos variables comunes a ambos procesos, que podrán ser consultadas por todos ellos. Supondremos que sólo tenemos 2 procesos, aunque puede generalizarse para N procesos Primer intento Ya hemos mencionado que para controlar la exclusión mutua es necesario que los procesos tengan un pre-protocolo y un post-protocolo que se ejecuten antes y después de su sección crítica. Lo más sencillo entonces es pensar en una variable global que indique a qué proceso le toca el turno. Debemos recordar que cada hilo en Java tiene un nombre, o bien un nombre específico proporcionado por el programador, o bien un nombre genérico proporcionado por Java. Estos nombres proporcionados por Java siguen la estructura Thread-x, donde x es un número consecutivo y único para cada hilo, por lo que permiten ordenar los hilos siguiendo un orden definido. Pues bien, podemos crear una variable entera global turno que indique si es el turno del hilo 0 o del hilo 1. Cada hilo comprueba en su pre-protocolo si el número de la variable turno coincide con su número de proceso, el expresado en el nombre generado automáticamente. Si as así, continua y ejecuta el código de su sección crítica y el post-protocolo. Si no, entra en un bucle hasta que tenga permiso para ejecutar su sección crítica. Cuando tras ejecutar su sección crítica, ejecute su post-protocolo, cambiará en él el valor de la variable turno para que indique al otro hilo (o al siguiente en el caso de N procesos). 2

4 Otra opción sería distinguir el hilo por su identificador, que es único y no puede cambiar mientras el hilo exista. Para ello habría que almacenar los identificadores de los hilos en una estructura a la que puedan acceder todos. Esto habría que hacerlo desde el programa principal antes de lanzarlos. Esta forma además nos permite cambiar los nombres de los hilos a nuestro antojo. Veamos cómo quedaría su código: /** * Programa de prueba del intento 1. * Natalia Partera 1.0 */ public class PrimerIntento extends Thread public static volatile long turno; public static volatile long[] turnos; public static volatile int indice = 0; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); while (turno!= this.getid()) //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); if(indice == 1) indice = 0; else ++indice; turno = turnos[indice]; public static void main(string[] args) throws InterruptedException PrimerIntento t1 = new PrimerIntento(); PrimerIntento t2 = new PrimerIntento(); turnos = new long[2]; turnos[0] = t1.getid(); turnos[1] = t2.getid(); turno = turnos[indice]; 3

5 t1.start(); t2.start(); t1.join(); t2.join(); Hay un problema en este modelo, y es que obliga a que haya una alternancia entre los 2 hilos, o que se ejecuten en un cierto orden si son más de 2, antes de que el mismo hilo pueda volver a tener acceso al recurso crítico. Además, si uno de los dos hilos muere o es eliminado, el otro proceso se bloquea en su sección crítica. Estos problemas se deben a que los hilos comprueban y modifican el valor de una misma variable, y tan sólo dependen de ella Segundo intento En esta ocasión, vamos a intentar solucionar el problema del intento anterior añadiendo más variables de control. Ahora cada hilo tendrá su propia variable de control que reflejará si los demás pueden usar el recurso crítico o no. Las variables de control seguirán siendo enteras, y ahora su valor se sustituirá por 0 y 1, o si lo prefiere, puede usar una variable booleana en su lugar. Cuando un hilo quiere entrar en su sección crtíca, coloca su variable a 0, indicando a los demás hilos que no intenten obtener el recurso crítico, que no pueden. Una vez que el hilo llega al post-protocolo coloca su variable de control a 1, indicando que el recurso crítico está libre. Si un hilo desea ejecutar su sección crítica, comprobará que todas las demás variables de control sean distintas de 0. Si no es así, espera. Veamos cómo quedaría su código: /** * Programa de prueba del intento 2. * Natalia Partera 1.0 */ public class SegundoIntento extends Thread public static volatile boolean[] permisos; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); String name = this.getname(); name = name.replace("thread-", ""); int numthread = Integer.parseInt(name); int otrothread; if (numthread == 0) 4

6 otrothread = 1; else otrothread = 0; System.out.println(this.getName() + ": permisos[otrothread] = " + permisos[otrothread]); while (permisos[otrothread] == false) System.out.println(this.getName() + ": En el bucle, permisos[" + otrothread + "] = " + permisos[otrothread]); permisos[numthread] = false; //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); permisos[numthread] = true; public static void main(string[] args) throws InterruptedException SegundoIntento t1 = new SegundoIntento(); SegundoIntento t2 = new SegundoIntento(); permisos = new boolean[2]; for (int i = 0; i < 2; ++i) permisos[i] = true; t1.start(); t2.start(); t1.join(); t2.join(); Desgraciadamente, este intento no cumple con el requerimiento de exclusión mutua. Puede darse el caso de que los hilos se intercalen al comprobar las demás variables de control y al entrar luego en su sección crítica y que al final acaben los dos hilos ejecutando a la vez su sección crítica. Es decir, puede pasar lo siguiente: 1. P 1 comprueba C 2 y encuentra que C 2 = P 2 comprueba C 1 y encuentra que C 1 = P 1 pone C 1 a P 2 pone C 2 a Ambos procesos entran en sus secciones críticas. 5

7 2.3. Tercer intento Para evitar la situación anterior, se puede cambiar el orden en el que se espera en el bucle y se cambia la variable de control. Para que no obtengan dos hilos el permiso para entrar, lo que se hace ahora es que primero los hilos declaran su intención (cambiando su variable) y luego esperan a poder entrar en la sección crítica. De este modo se asegura que solamente un hilo entre en su sección crítica a la vez. Cuando un hilo llega a su pre-protocolo anuncia su intención de ejecutar su sección crítica cambiando el valor de su variable de control a 0. Luego el hilo se queda esperando en un bucle hasta que las demás variables de control valen 1. En ese momento el hilo entra en su sección crítica. Después, en su postprotocolo, cambia el valor de su variable de control a 1 para indicar que ha dejado libre el recurso crítico. Veamos cómo quedaría su código: /** * Programa de prueba del intento 3. * Natalia Partera 1.0 */ public class TercerIntento extends Thread public static volatile boolean[] permisos; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); String name = this.getname(); name = name.replace("thread-", ""); int numthread = Integer.parseInt(name); int otrothread; if (numthread == 0) otrothread = 1; else otrothread = 0; permisos[numthread] = false; while(permisos[otrothread] == false) //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); permisos[numthread] = true; 6

8 public static void main(string[] args) throws InterruptedException TercerIntento t1 = new TercerIntento(); TercerIntento t2 = new TercerIntento(); permisos = new boolean[2]; for (int i = 0; i < 2; ++i) permisos[i] = true; t1.start(); t2.start(); t1.join(); t2.join(); Con este código hemos conseguido que sólo un hilo ejecute su sección crítica a la vez. Sin embargo, el programa puede bloquearse si algunas instrucciones de distintos hilos se ejecutan entrelazadas y concurrentemente: 1. P 1 pone C 1 a P 2 pone C 2 a P 1 comprueba C 2 y encuentra que C 2 = 0, por lo que permanece en el bucle. 4. P 2 comprueba C 1 y encuentra que C 1 = 0, por lo que permanece en el bucle. Esta secuencia demuestra cómo pueden bloquearse los hilos tras declarar su intención de ejecutar su sección crítica pero sin poder entrar en ella Cuarto intento Este intento continua el razonamiento del anterior, y obliga a un hilo que abandone su intención de ejecutar su sección crítica si descubre que puede existir un estado de contención con otro proceso, donde se bloquean mutuamente. Para obligar a un hilo que abandone su intención momentaneamente por si existe contención, se cambia el valor de su variable de control dos veces mientras que está en el bucle esperando. De este modo si está esperando y otro hilo desea ejecutar su sección crítica también, al poner su variable de control a 1, el otro ejecuta su sección crítica. Luego vuelve a cambiar el valor de su variable de control para volver a indicar su intención de entrar en su sección crítica. Veamos cómo quedaría su código: /** * Programa de prueba del intento 4. * Natalia Partera 1.0 */ 7

9 public class CuartoIntento extends Thread public static volatile boolean[] permisos; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); String name = this.getname(); name = name.replace("thread-", ""); int numthread = Integer.parseInt(name); int otrothread; if (numthread == 0) otrothread = 1; else otrothread = 0; permisos[numthread] = false; while(permisos[otrothread] == false) permisos[numthread] = true; permisos[numthread] = false; //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); permisos[numthread] = true; public static void main(string[] args) throws InterruptedException CuartoIntento t1 = new CuartoIntento(); CuartoIntento t2 = new CuartoIntento(); permisos = new boolean[2]; for (int i = 0; i < 2; ++i) permisos[i] = true; t1.start(); t2.start(); t1.join(); t2.join(); Con este algoritmo tenemos garantizada la exclusión mutua. Sin embargo puede dar lugar a procesos ansiosos. Veamos una secuencia en la que esto puede ocurrir: 8

10 1. P 1 pone C 1 a P 2 pone C 2 a P 2 comprueba C 1 y encuentra que C 1 = 0, por lo que permanece en su bucle y cambia C 2 a P 1 entra en su sección crítica y su post-protocolo, donde cambia C 1 a P 2 sigue en el bucle y cambia C 2 a En este punto, si P 1 no desea volver a entrar en su sección crítica, P 2 puede por fin entrar. Pero si P 1 entra en su pre-protocolo y vuelve a solicitar entrar en su sección crítica, P 2 se encontraría atrapado en el bucle. Otro defecto del algoritmo es que puede provocar un livelock. Esto puede ocurrir cuando ambos hilos se bloqueen y se sigan ejecutando concurrente y entrelazadamente, cambiando ambos los valores de sus variables de control pero sin llegar a ejecutar su sección crítica ninguno de los dos: 1. P 1 pone C 1 a P 2 pone C 2 a P 2 comprueba C 1 y encuentra que C 1 = 0, por lo que permanece en el bucle y cambia C 2 a P 2 sigue en el bucle y cambia C 2 a P 1 comprueba C 2 y encuentra que C 2 = 0, por lo que permanece en el bucle y cambia C 1 a P 1 sigue en el bucle y cambia C 1 a P 2 comprueba C 1 y encuentra que C 1 = 0, por lo que permanece en el bucle. 8. P 1 comprueba C 2 y encuentra que C 2 = 0, por lo que permanece en el bucle Algoritmo de Dekker El problema del último intento es que por no querer producir un bloqueo, no insiste el hilo lo suficiente en su derecho a usar el recurso crítico. Si lo combinamos con el primer intento, obligará a que alguno de los hilos entre en su sección crítica en el caso de que los dos se estén cediendo el recurso crítico entre ellos mutuamente, es decir, si hay contención. Primero un hilo anuncia su deseo de entrar en la sección crítica, por ejemplo el hilo 1. Pero antes de entrar en la sección crítica comprueba si tiene derecho a insistir en ello, comprobando el valor de la variable turno. Si no tiene derecho, desactiva el anuncio de entrada en la sección crítica, poniendo su variable de control (C 1 ) a 1, y quedando en espara hata que reciba el turno. Cuando el otro hilo (hilo 2) completa su sección crítica, el hilo 1 recibe el turno. En ese momento, el hilo 1 vuelve a ajustar su variable de control a 0 y entra en su sección crítica. Al salir de la sección crítica, cambia el valor de su variable de control y le devuelve el turno al otro hilo. 9

11 Veamos cómo quedaría su código: /** * Programa de prueba del intento 5: algoritmo de Dekker. * Natalia Partera 1.0 */ public class Dekker extends Thread public static volatile long turno; public static volatile long[] turnos; public static volatile int indice = 0; public static volatile boolean[] permisos; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); String name = this.getname(); name = name.replace("thread-", ""); int numthread = Integer.parseInt(name); int otrothread; if (numthread == 0) otrothread = 1; else otrothread = 0; permisos[numthread] = false; while(permisos[otrothread] == false) if(turno!= this.getid()) permisos[numthread] = true; while(turno!= this.getid()) permisos[numthread] = false; //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); permisos[numthread] = true; if(indice == 1) indice = 0; else ++indice; turno = turnos[indice]; 10

12 public static void main(string[] args) throws InterruptedException Dekker t1 = new Dekker(); Dekker t2 = new Dekker(); turnos = new long[2]; turnos[0] = t1.getid(); turnos[1] = t2.getid(); turno = turnos[indice]; permisos = new boolean[2]; for (int i = 0; i < 2; ++i) permisos[i] = true; t1.start(); t2.start(); t1.join(); t2.join(); El algoritmo de Dekker es correcto y satisface los requerimientos de exclusión mutua y ausencia de bloqueos. Ningún hilo puede volverse ansioso y en ausencia de contención, un proceso entra en su sección crítica inmediatamente si lo desea. 3. Variables volatile Como habrá observado en los ejemplos anteriores, las variables globales han sido definidas como volatile. Esta palabra reservada puede usarse en tipos primitivos o en objetos. Si una variable es volatile el compilador está obligado a leer y escribir su valor en memoria cada vez que sea accedida, en lugar de hacerlo desde o sobre la memoria caché. Esto permite que una variable global sea accedida por distintos hilos que modifiquen su valor y que sea sincronizada automáticamente en cada acceso. 4. Ejercicios Ejercicio 1 Implemente el algoritmo de la panadería de Lamport para dos variables. Compílelo varias veces para comprobar que funciona correctamente. Puede comparar su código con el que se encuentra en

13 5. Soluciones de los ejercicios En esta sección encontrará las soluciones a los ejercicios propuestos a lo largo del guión Ejercicio 1 A continuación puede ver la implementación del algoritmo de Lamport para 2 hilos: /** * Programa de prueba del algoritmo de Lamport. * Natalia Partera 1.0 */ public class Lamport extends Thread public static volatile int[] turnos; public void run() for(int i = 0; i < 10; ++i) //Antes del pre-protocolo System.out.println(this.getName() + ": Antes del pre-protocolo."); //Pre-protocolo System.out.println(this.getName() + ": Pre-protocolo"); String name = this.getname(); name = name.replace("thread-", ""); int numthread = Integer.parseInt(name); int otrothread; if (numthread == 0) otrothread = 1; else otrothread = 0; turnos[numthread] = 1; turnos[numthread] = turnos[otrothread] + 1; while (turnos[otrothread]!= 0 && turnos[numthread] > turnos[otrothread]) //Sección crítica System.out.println(this.getName() + ": Sección crítica. Vuelta " + i); //Post-protocolo System.out.println(this.getName() + ": Post-protocolo"); turnos[numthread] = 0; public static void main(string[] args) throws InterruptedException Lamport t1 = new Lamport(); Lamport t2 = new Lamport(); 12

14 turnos = new int[2]; turnos[0] = 0; turnos[1] = 0; t1.start(); t2.start(); t1.join(); t2.join(); 13