PDF de programación - Capitulo 8. Comunicación y sincronización basada en variables compartidas

CAPÍTULO 8. Comunicación y sincronización basada en variables



compartidas



8 Comunicación y sincronización basada en variables compartidas.............................................2
Exclusión mutua y condición de sincronización. ...............................................................2
8.1
Espera ocupada...................................................................................................................3
8.2
Suspender y reanudar .........................................................................................................8
8.3
Semáforos .........................................................................................................................10
8.4
Críticas a los semáforos................................................................................................12
8.4.7
8.5
Regiones criticas condicionales........................................................................................13
8.6 Monitores..........................................................................................................................14
Llamadas anidadas al monitor. .....................................................................................17
8.6.4
8.6.5
Criticas a los monitores. ...............................................................................................17
8.7
Objetos protegidos............................................................................................................18
8.8 Métodos de sincronización. ..............................................................................................21
Espera y notificación. ...................................................................................................24
8.8.1
8.8.2
Herencia y sincronización. ...........................................................................................30



Rafael Álvarez García
Última revisión 05-12-07
[email protected]


Nota importante:

Este documento no pretende reemplazar al material propuesto por la UNED para la
asignatura Sistemas en Tiempo Real.

Cualquier sugerencia, comentario o corrección sobre este documento, envíelo a
[email protected] para poder realizar los cambios necesarios.



1



8 Comunicación

y

sincronización basada

en

variables

compartidas


Las mayores dificultades asociadas con la programación concurrente surgen de la interacción
de procesos. Casi nunca los procesos son independientes entre si. El comportamiento correcto de
un programa concurrente depende estrechamente de la sincronización y la comunicación entre
procesos. En su sentido más amplio, sincronizar es satisfacer las restricciones en el entrelazado
de las acciones de diferentes procesos (por ejemplo, una acción particular de un proceso solo
ocurre después de una acción especifica de otro proceso).


La comunicación entre procesos se basa normalmente o en el uso de variables compartidas o
en el paso de mensajes. Las variables compartidas son objetos a los que puede acceder más de un
proceso; la comunicación puede realizarse, por tanto, referenciado en cada proceso dichas va-
riables cuando sea apropiado. El paso de mensajes implica el intercambio explicito de datos en-
tre dos procesos mediante un mensaje que pasa de un proceso a otro siguiendo algún mecanismo.
Hay que señalar que la elección entre variables compartidas y paso de mensajes deben realizarla
los diseñadores de los lenguajes o de los sistemas operativos, y no implica que deba utilizarse un
método particular de implementación. Las variables compartidas son más fáciles de soportar si
hay memoria compartida entre procesos, pero pueden ser utilizadas incluso si el hardware
incorpora un medio de comunicación. De forma similar, puede obtenerse una primitiva de paso
de mensajes mediante memoria compartida o mediante una red física de paso de mensajes.



8.1 Exclusión mutua y condición de sincronización.


Aunque las variables compartidas parecen una forma directa de pasar información entre
procesos, su uso no restringido es poco fiable e inseguro, debido a los múltiples problemas de
actualización. Considere dos procesos que actualizan una variable compartida, X, mediante la
sentencia:


X := X+l

En la mayoría del hardware esto no se ejecuta como una operación indivisible (atómica),

sino que se implementara en tres instrucciones distintas:

(1) Carga el valor de X en algún registro (o en la parte superior de la pila).

(2) Incrementa el valor en el registro en 1.

(3) Almacena el valor del registro de nuevo en X.


Como ninguna de las tres operaciones es indivisible, dos procesos que actualicen la variable
simultáneamente generarían un entrelazamiento que podía producir un resultado incorrecto. Por
ejemplo, si X era originalmente 5, los dos procesos podrían cargar cada uno 5 en sus registros,
incrementarlos, y almacenar entonces 6.


Una secuencia de sentencias que debe aparecer como ejecutada indivisiblemente se
denomina sección critica. La sincronización que se precisa para proteger una sección crítica se
conoce como exclusión mutua. La atomicidad, aunque ausente de la operación de asignación, se
supone que esta presente en el nivel de la memoria. Por tanto, si un proceso esta ejecutando X :=



2

5 simultáneamente con otra ejecución de X : =6, el resultado sería o 5 o 6 (no otro valor). Si esto
no fuera cierto, seria difícil razonar sobre los programas concurrentes o implementar niveles de
atomicidad más altos, como sincronización de exclusión mutua. Sin embargo, esta claro que si:
dos procesos están actualizando un objeto estructurado, esta atomicidad solo se aplicara ai nivel
del elemento palabra.


EI problema de la exclusión mutua esta en el núcleo de la mayoría de las sincronizaciones de
procesos concurrentes, y tiene un gran interés teórico y practico. La excusión mutua no es la
única sincronización importante; evidentemente, si dos procesos no comparten variables no se
necesita exclusión mutua. La sincronización condicionada, o de condición, es otro requisito
significativo, y es necesaria cuando un proceso desea realizar una operación que solo puede ser
realizada adecuadamente, o de forma segura, si otro proceso ha realizado alguna acción o esta en
algún estado definido.


Un ejemplo de sincronización de condición se produce al usar búferes. Dos procesos
intercambiando datos funcionaran mejor si no se comunican directamente, sino mediante un
búfer. La ventaja esta en el desacoplamiento de los procesos, que permitirá pequeñas
fluctuaciones en la velocidad de trabajo de los dos procesos. Un proceso de entrada, por ejemplo,
podrá recibir ráfagas de datos que deberá almacenar en el búfer destinado al proceso de usuario
correspondiente. Los búferes son habituales en la programación concurrente para enlazar dos
procesos, que forman un sistema productor-consumidor.


Si se implementa un buffer finito (limitado), se precisa de dos condiciones de sincronización.
En primer lugar, el proceso productor no deberá intentar llenar el búfer si este esta lleno. En
segundo lugar, no se permite al proceso consumidor extraer objetos del búfer si esta vacío.
Además, si es posible insertar y extraer simultáneamente, habrá que garantizar que se excluyan
mutuamente ciertas operaciones, como por ejemplo que dos productores utilicen a la vez el
apuntador «hueco libre siguiente» del búfer, corrompiéndolo.


La implementación de cualquier forma de sincronizaeión, suele acarrear la detención de

algún proceso hasta que pueda continuar.



8.2 Espera ocupada.


Una forma de implementar la sincronización es comprobar las variables compartidas que
actúan como indicadores en un conjunto de procesos. Esta aproximación sirve razonablemente
bien para implementar sincronización de condición, pero no hay un método simple para la
exclusión mutua. Para indicar una condición, un proceso activa el valor de un indicador; para
esperar por esta condición, otro proceso comprueba este indicador, y continúa solo cuando se lee
el valor apropiado:

process P1; (* proceso esperando *)

while indicador = abajo do

nu

ll

end;

end P1;



3

process P2; {* proceso indicando *)

indicador := arriba;

end P2;


Si la condición no es aún correcta (esto es, si el indicador esta aun abajo), Si no tiene
elección, y deberá continuar en el bucle para volver a comprobar el indicador. Esto se conoce
como espera ocupada, y también como giro y a los indicadores como cerrojos de giro (spin
locks).


Los algoritmos de espera ocupada son en general ineficientes, y hacen que los procesos
consuman ciclos de proceso en un trabajo inútil, Es más, en sistemas multiprocesador, pueden
dar lugar a un exceso de tráfico en el bus de memoria o en la red (si el sistema es distribuido)
Además, no es posible imponer fácilmente disciplinas de colas si hay más de un proceso
esperando por una condición (es decir, comprobando el valor de un indicador).


Si los algoritmos usados son más complejos, la exclusión mutua se vuelve también más
dificultosa. Considere dos procesos (P1 y P2) con secciones críticas mutuas. Para proteger el
acceso a ellas, se puede pensar en un protocolo que es ejecutado por cada proceso antes de entrar
en la sección critica, y que va seguido de otro protocolo de salida. El aspecto que tendría cada
proceso viene a ser el siguiente:


process P;

loop

protocolo de entrada

sección critica

protocolo de entrada
sección no critica

end

end P;


Ant