PDF de programación - Tema 3 - concurrencia de memoria común - Programación Avanzada

Asignatura 780014

Programación Avanzada

TEMA 3 – CONCURRENCIA DE MEMORIA COMÚN

Concurrencia de memoria común

 Programación Concurrente de Memoria Común:

 Cuando tenemos una única memoria con:

 El Sistema Operativo (SO)
 Todos los procesos
 Todos los datos
 Todos los recursos


 Podemos tener concurrencia

 Con 1 procesador
 Con n procesadores

Concurrencia de memoria común

 Cada proceso, su propio espacio de direcciones

 Lo asigna y protege el SO

 Sin acceso al de otros procesos

 El SO ofrece zonas de memoria compartida

 Variables compartidas
 Utilizadas para la coordinación

 Comunicación
 Sincronización

Coordinación de procesos

 Usando las variables compartidas

 Dos modelos puros

 Comunicación = intercambio de datos mediante variables

compartidas sin controles

 Sincronización = controlar detención y reanudación de procesos y

su relación temporal

 Un modelo míxto

 Comunicación sincronizada = intercambio de información con

control del momento en que se realiza para asegurar su integridad

Ejemplos de coordinación

 Comunicación pura

 Un ejemplo podría ser el formado por dos procesos. Uno se encarga de tomar la

temperatura en un sensor y escribirla en una variable compartida. El otro lee dicho
valor y lo muestra en un display.

Ejemplos de coordinación

 Sincronización pura

 Un sistema en el que un proceso está encargado de inicializar una impresora y otros tienen que

imprimir en esa misma impresora una vez que esté lista.

 El proceso de inicialización dura 10 seg. y los otros procesos tardan entre 2 y 15 seg. en preparar

cada documento para imprimirlo.

 Merece la pena que todos los procesos se inicien a la vez, para que se ejecute la mayor cantidad de

trabajo en paralelo, pero las impresiones no podrán empezar hasta que el proceso especial inicialice
la impresora.

Ejemplos de coordinación

 Comunicación sincronizada

 Un conjunto de cabinas de votación y un sistema central de recuento.
 Cada cabina esta controlada por un proceso y el sistema central por otro.
 El valor de cada voto se pone en una variable compartida por cada cabina y además

tendremos variables adicionales de control que nos informe de si cada voto es nuevo o
ya ha sido contabilizado por el sistema central.

El problema de la coordinación

 La coordinación mediante variables compartidas,

 Pone en riesgo de incosistencia dichas variables

 La solución a este riesgo es:

 Garantizar la Exclusión mútua entre procesos cuando acceden

a la misma variable compartida

 Definiciónes:

 Sección crítica es:

 Fragmento de código donde la corrección de un programase ve

comprometida por el uso de variables compartidas

 Solución:

 Asegurar la ejecución en exclusión mútua de toda SC sobre una

misma variable compartida

Procesos vs Hilos

 Los modelos de coordinación necesitan variables

compartidas
 En concurrencia con procesos, proporcionadas por SO

 En concurrencia con hilos, cualquier variable del programa



 Java = hilos

 Usaremos atributos de objetos para realizar la coordinación

 Crearemos objetos que todos los hilos a coordinar “conocen”
 Tendremos atributos en esos objetos compartidos que se usarán

como variables compartidas y que deberán ser protegidos

Historia de Java

 Nació como herramienta de programación

en el “Green Project” de Sun
Microsystems en 1991.

 El equipo (Green Team), de 13 personas

fue dirigido por James Gosling.

 Objetivos:

 Paradigma de la programación orientada a

objetos.

 Ejecución de un mismo programa en múltiples

sistemas operativos.

 Soporte para trabajo en red.
 Ejecución de código en sistemas remotos de

forma segura.

 Fácil de usar y basado en lo mejor de otros

lenguajes O.O como C++.



Video

Historia de Java

Versiones:
 JDK 1.0 (1996) — Primer lanzamiento
 JDK 1.1 (1997) — AWT, JavaBeans, JDBC, RMI
 J2SE 1.2 (1998) — Swing integrada en las clases básicas, compilador

JIT, Java IDL

 J2SE 1.3 (2000) — JavaSound, Java Naming and Directory Interface

(JNDI), RMI basado en CORBA

 J2SE 1.4 (2002) — Expresiones regulares al estilo Perl, Encadenación

de excepciones

 J2SE 5.0 (2004) — Conversión de tipos para colecciones,

Enumeraciones, JSR 166: Concurrency Utilities

 Java SE 6 (2006) — APIs para combinar con PHP, Python, Ruby y

JavaScript. Servicios web JAX-WS 2.0, JAXB 2.0, STAX y JAXP.Mejora
en rendimiento.

 Java SE 7 (2011) — Soporte para XML. Superpaquetes. BigDecimal con

operandos...

Concurrencia en Java

 Utilizamos varios elementos básicos

 Objetos tipo hilo (clase Thread)

 Objetos con atributos para coordinación

 Modificador Synchronized para asegurar la exclusión mutua
 Combinaciones de modificadores de acceso (private, public,

protected)

 Crearemos comportamientos avanzados mediante

algoritmos

 Utilizaremos elementos avanzados del lenguaje

 De la “JSR 166: Concurrency Utilities”

Algoritmos para exclusión mutua (problema)

Problema:
Dos procesos (esquimales) comparten un recurso (un agujero hecho
en el hielo) que necesitan utilizar (pescar). Por su naturaleza (tamaño) el
acceso a dicho recurso debe ser exclusivo.
Escribir el algoritmo que represente el comportamiento de los
esquimales utilizando variables compartidas (que representen el estado
del recurso crítico) para resolver el problema de exclusión mutua
planteado.

Algoritmos para exclusión mutua (1º)

Primera aproximación

 Una pizarra dentro de un igloo (por su acceso y tamaño solo
puede haber un esquimal dentro => RC) será la variable
compartida.

 Cuando el esquimal P0 quiera ir a pescar, entrará en el igloo y
mirará la pizarra. Si hay un 1, se va a dar una vuelta por ahí. Si
hay un 0, se va a pescar. Cuando vuelve de pescar, entra y pone
un 1.

Si P1 hace lo mismo, cambiando el 0 por el 1.

Algoritmos para exclusión mutua (1º)

Primera aproximación en JAVA

public class Main {

public static void main(String[] args) {

Igloo igloo=new Igloo();

public class Esquimal extends Thread {

private int id;

private Igloo ig;

public Esquimal(int id, Igloo ig){

Esquimal cero=new Esquimal(0,igloo);

this.id=id; this.ig=ig; start();

Esquimal uno=new Esquimal(1,igloo);

}

}

}

public class Igloo {

private int turno=0;

public synchronized int miraTurno(){

return turno;

}

public void run(){

while (true){

while(ig.miraTurno()!=id){ //pasear

try{sleep(10+(int)(20.*Math.random()));}

catch(Exception e){}

}

System.out.println("Esq."+id+" pescando");

try{sleep(100+(int)(200.*Math.random()));}

public synchronized void cambiaTurno(int id){

turno=(id+1)%2;

catch(Exception e){}

ig.cambiaTurno(id);

}

}

}

}

}

Algoritmos para exclusión mutua (1º)

Primera aproximación. Problema: Alternancia



 Se consigue la exclusión mutua a cambio de un funcionamiento
muy rígido: Pesca P0, pesca P1, pesca P0, ….

 Si un proceso quiere usar el recurso crítico, no podrá si no es su
turno. Tendrá que esperar a que sea usado por el otro proceso.
run:

Esquimal 0 pescando

Esquimal 1 pescando

Esquimal 0 pescando

Esquimal 1 pescando

Esquimal 0 pescando

Esquimal 1 pescando

Esquimal 0 pescando

Esquimal 1 pescando

…

Algoritmos para exclusión mutua (2º)

Segunda aproximación

 Para evitar la alternancia, se usan dos igloo (dos variables
compartidas), uno para cada esquimal.

 Dentro de cada igloo hay una pizarra en la que su propietario
indica “pescando” o “no pescando”.

 Si un esquimal quiere pescar, va al igloo del otro y mira. Si está
pescando, espera. Si no, va a su propio igloo, indica que está
“pescando” y se va a pescar.

Algoritmos para exclusión mutua (2º)

Segunda aproximación en JAVA

public class Main {

public static void main(String[] args) {

Igloo ig[]=new Igloo[2];

public class Esquimal extends Thread {

private int yo,tu;

private Igloo[] ig=new Igloo[2];

public Esquimal(int id, Igloo[] ig){

ig[0]=new Igloo(false); ig[1]=new Igloo(false);

this.yo=id; tu=(id+1)%2; this.ig=ig; start(); }

Esquimal cero=new Esquimal(0,ig);

Esquimal uno=new Esquimal(1,ig); } }

public void run(){

while (true){

public class Igloo {

private boolean pescando;

public Igloo(boolean b) {

pescando=b; }

public synchronized void pidoTurno(){

pescando=true; } //Se va a pescar

public synchronized void cedoTurno(){

pescando=false; } //vuelve de pescar

public synchronized boolean estaPescando(){

return pescando; }

}

while(ig[tu].estaPescando()){ //Pasear

try{sleep(1+(int)(2.*Math.random()));} … }

ig[yo].pidoTurno();

if(ig[tu].estaPescando())

System.out.println(“P"+yo+“ y P "+tu+"pescando");

try{sleep(1+(int)(2.*Math.random()));} …

ig[yo].cedoTurno();

try{sleep(1+(int)(2.*Math.random()));} …

}

}

}

Algoritmos para exclusión mutua (2º)

Segunda aproximación. Problema: Falta de Exclusión



 Puede ocurrir que P0 vaya a ver si P1 está pescando. Ve que no
y se vuelve a su igloo, para apuntar que se va a pescar.

 Pero mientras estaba en el igloo de P1, éste fue a mirar al de P0
y ve que no estaba pescando.

 Vuelve a su igloo y apunta que se va a pescar.

 => No hay Exclusión Mutua en relación con el recurso crítico.


run:

P1 y P0 pescando



Algoritmos para exclusión mutua (3º)

Tercera aproximación.



 La situación anterior se ha pro