Programacion concurrente

Procesos
Administración, Coordinación y Sincronización
SISTEMAS OPERATIVOS . ING. PURA CASTILLO
UNIVERSIDAD POLITECNICA TERRITORIAL DE LARA

PROGRAMACION CONCURRENTEPROGRAMACION CONCURRENTE
La programación concurrente es la simultaneidad en la ejecución de múltiples tareas interactivas. Estas tareas
pueden ser un conjunto de procesos o hilos de ejecución creados por un único programa. Las tareas se pueden
ejecutar en un sola UCP (multiprogramación), en varios procesadores o en una red de computadores
distribuidos. La programación concurrente está relacionada con la programación paralela, pero enfatiza más la
interacción entre tareas. Así, la correcta secuencia de interacciones o comunicaciones entre los procesos y los
nodos los procesos coordinados de recursos que se comparten por tareas son las claves de esta disciplina.

La programación concurrente tiene capacidad para realizar varias tareas al mismo tiempo o muchas tareas
en una sola PC con un procesador o varios.
Es necesario tratar conceptos importantes como lo son:
• Multitareas:Multitareas: Es la capacidad de un sistema operativo para ejecutar varios procesos al mismo tiempo
corriendo sobre un procesador.
• Multiprogramación Es la técnica que permite que dos o mas programas ocupen la misma unidad de
memoria principal y que sean ejecutados al mismo tiempo.
La multiprogramación se refiere a dos o mas programas corriendo o procesándose al mismo tiempo; La
multiprogramación se controla a través del sistema operativo, el cual observa los programas y los vigila
hasta que estén concluidos.
• Concurrencia: La concurrencia es el punto clave en los conceptos de multitarea, multiprogramación y
multiproceso, la concurrencia comprende un gran numero de cuestiones de diseño incluyendo la
comunicación entre procesos, la compartición y competencia por los recursos, la sincronización de la
ejecución de varios procesos y la asignación del procesador a los procesos.

COMUNICACIÓN Y SINCRONIZACIÓN DE PROCESO
La sincronización entre procesos puede definirse como la necesidad que tienen algunos procesos de
bloquearse en determinadas circunstancias y ser despertados cuando ocurren ciertos eventos.
La Exclusión Mutua
Consiste en que un solo proceso excluye temporalmente a todos los demás para usar un recurso
compartido de forma que garantice la integridad del sistema
Requisitos para la Exclusión Mutua
 En cada momento sólo se la permite a un proceso estar en sección critica para un recurso
 Un proceso que termina en su sección no crítica debe hacerlo sin interferir con otros procesos
 No interbloqueo o inanición
 Un proceso no debe ser demorado en su acceso a la sección crítica cuando no hay otro proceso
usándola.
No se debe asumir nada relativo a la velocidad de los procesos o el número de ellos.
 Un proceso permanece en su sección crítica por un tiempo finito

Sección Critica
Sección Crítica Porción de código con variables compartidas y que debe ejecutarse en exclusión mutua. Se
tienen que cumplir una serie de condiciones:
 Hay que garantizar la exclusión mutua entre los diferentes procesos a la hora de acceder al recurso
compartido. No puede haber 2 procesos dentro de sus respectivas secciones críticas.
 No se deben hacer suposiciones en cuanto a la velocidad relativa de los procesos en conflicto.
 Ningún proceso que este fuera de su sección critica debe interrumpir a otro para el acceso a la sección critica.
Cuando mas de un proceso desee entrar en su sección critica, se le debe conceder la entrada en un tiempo
finito.
Los lenguajes concurrentes deben proporcionar herramientas para resolver este tipo de problemas.
Para la solución al problema de la exclusión mutua hay 3 tipos de soluciones
 Soluciones software
 Soluciones hardware
 Soluciones aportadas por el sistema operativo

Soluciones Software Para La Exclusión Mutua
 Algoritmo de Dekker
 Algoritmo de Peterson
 Semáforos.
 Monitores.
 Paso de Mensajes
Soluciones Hardware Para La Exclusión Mutua
 Inhibición de Interrupciones
 Instrucciones máquina especiales
 Instrucción Test and Set.
Algoritmo de Dekker: Es un algoritmo de programación concurrente para exclusión mutua, que permite a
dos procesos o hilos de ejecución compartir un recurso sin conflictos. Fue uno de los primeros
algoritmos de exclusión mutua inventados, implementado por Edsger Diikstra.
Existen cinco versiones del algoritmo Dekker, teniendo ciertos fallos los primeros
cuatro. La versión 5 es la que trabaja más eficientemente, siendo una combinación de
la 1 y la 4

Primer intento de Dekker: El proceso no puede hacer nada productivo hasta que obtiene permiso para entrar en su
sección crítica.
Segundo intento de Dekker: Este método no garantiza la exclusión mutua debido a que cada proceso puede
comprobar su flag y proceder a la entrada en la sección critica al mismo tiempo
Tercer intento de Dekker: El interbloqueo es posible cuando dos procesos activan sus flags para entrar en sección
crítica y luego deben esperar a que el otro salga de la sección crítica.
Cuarto intento de Dekker: Es posible que todos los procesos activen sus flags, comprueben los otros procesos y
desactiven sus flags. Pero esto no dura mucho tiempo, por eso no se considera interbloqueo aunque este retraso es
injustificable.
Solución Correcta: Cada proceso obtiene un turno para su sección crítica. Si un proceso quiere entrar en su sección
crítica, activa un flag y espera su turno

Algoritmo Dekker

Algoritmo de Peterson
Peterson desarrolló el primer algoritmo (1981) para dos procesos que fue una simplificación del algoritmo
de Dekker para dos procesos. Posteriormente este algoritmo fue generalizado para que funcione para N
procesos .En el algoritmo para N procesos las variables c[i] además de valer "verdadero" y "falso", pueden
valer "en sección critica" y turno desde 1 hasta N.

SEMÁFORO
Un semáforo es una estructura diseñada para sincronizar dos o más procesos, de modo que su ejecución se realice de forma
ordenada y sin conflictos entre ellos consta de dos operaciones: Primitivas señal , Espera
Originalmente definidas como P y V por que operan sobre un tipo especial de variable semáforo “S”. La variable semáforo
puede tomar valores enteros y, excepto posiblemente en su inicialización, solo puede ser accedida y manipulada por medio de
las operaciones : Signal, Wait
Solo se permiten tres operaciones sobre un semáforo:
1. Inicializa (s: Semáforo_Binario; v: integer) -- > poner el valor del semáforo s al valor de v (0,1).
2. Espera (wait)(s) if s = 1 then s: = 0 else Suspender la tarea que hace la llamada y ponerla en la cola de tareas.
3. Señal (signal)(s) if cola de tareas vacía then s : = 1 else Reanudar la primera tarea de la cola tareas

Características de los semáforos
Son independientes de la máquina
Son simples
Pueden trabajar con varios procesos
Pueden permitir que varios procesos entren en la sección crítica al mismo tiempo en caso de necesitarse esta
posibilidad
Doble uso de los semáforos:
Exclusión mutua
Sincronización

Codificación los semáforos
• Las primitivas P y V se realizan por software
• Razón: P y V se ven implicados en aspectos de planificación
• Partimos de la siguiente declaración:
typedef struct
{
int contador;
(cola q;)
int t; /* Para multiprocesadores */
} SEMAFORO;
• En el caso de los semáforos con espera activa el código entre paréntesis sobra

P y V en sistemas multiprocesador
P (SEMAFORO *s)
{
while (TAS(s->t) != 0);
if (s->contador > 0)
{
s->contador- = 1;
s->t = 0;
return;
}
Añadimos proc. a s->q
s->t = 0;
Planificación
}
V (SEMAFORO *s)
{
while (TAS(s->t) != 0);
if (s->q vacía)
{
s->contador+ = 1;
} else {
Sacar proceso de s->q;
Despertarlo;
}
s->t = 0;
}

Lectores-escritores
• Descripción:
• Los escritores acceden a la BBDD cuando no haya ningún otro escritor y ningún
lector. Semáforo escribir
• Los lectores acceden cuando no haya ningún escritor accediendo o esperando.
Semáforo leer
• Variables compartidas: LA, LE, EA, EE
• A estas variables accederemos en exclusión mutua protegidas con un semáforo
exmut
• Valores iniciales:
leer = escribir = 0
exmut = 1
LA = EA = LE = EE = 0
• Además: Los escritores tienen prioridad sobre los lectores

Lectores-escritores
Lector Escritor
P (exmut);
if ((EA + EE) == 0)
{
V (leer);
LA = LA + 1;
} else {
LE = LE + 1;
}
V (exmut);
P (leer);
Leemos los datos;
P (exmut);
LA = LA - 1;
if (LA == 0 && EE > 0)
{
V (escribir);
EA = EA + 1;
EE = EE - 1;
}
P (exmut);
if (( EA + LA + EE) == 0)
{
V (escribir);
EA = EA + 1;
} else {
EE = EE + 1;
}
V (exmut);
P (escribir);
Escribimos los datos;
P (exmut);
EA = EA - 1;
if (EE > 0)
{
V (escribir);
EA = EA + 1;
EE = EE - 1;
} else while (LE > 0) {
V (leer);
LA = LA + 1;
LE = LE - 1;
}
V (exmut);

Problema de los filósofos
void toma_tenedores(int i) {
P(exmut);
estado[i] = HAMBRIENTO;
comprueba(i);
V(exmut);
P(semaforo[i]);
} /* Fin de toma_tenedores */
void pon_tenedores(int i) {
P(exmut);
estado[i] = PENSANDO;
comprueba((i-1)%N);
comprueba((i+1)%N);
V(exmut);
} /* Fin de pon_tenedores */
void comprueba(int i)
{
if (estado[i] == HAMBRIENTO
&& estado[(i-1)%N] != COMIENDO
&& estado[(i+1)%N] != COMIENDO)
{
estado[i] = COMIENDO;
V(semaforo[i]);
}
} /* Fin de comprueba */
• ¿A qué valores se deben iniciar los semáforos?
• ¿Por qué la función comprueba siempre se invoca desde una
sección crítica?

• Problema: 1 barbero y N sillas de espera
• Si un cliente entra y no hay sillas, se va
• Semáforos:
• clientes: número de clientes en espera sin contar el que está en la silla del
peluquero
• barberos: número de barberos inactivos
• exmut: exclusión mutua
• Variable compartida:
• esperando: número de clientes esperando
• Inicialmente:
clientes=0 barberos=0 exmut=1 esperando=0
Problema del barbero dormilón

Barbero Cliente
do
{
P(exmut);
if (esperando < SILLAS) {
esperando++;
V(clientes);
V(exmut);
P(barberos);
/* Se corta el pelo */
} else {
V(exmut);
}
} while (PELOLARGO);
do
{
P(clientes);
P(exmut);
esperando=esperando-1;
V(barberos);
V(exmut);
/* Corta el pelo */
} while (TRUE);

Monitores
Es una construcción de alto nivel para sincronización.
Es mas fácil de controlar que los semáforos.
Se implementan como biblioteca de programas.
Es un modulo de software con 1 o + procedimientos, una secuencia de inicialización
y datos locales.
Características principales
– Las variables locales son accedidas sólo por el monitor
– El proceso entra en el monitor invocando uno de sus procedimientos
– Sólo un proceso puede estar ejecutando el monitor en cada instante dado
(ofrece exclusión mutua)
Ejemplos: Una estructura de datos compartida, puedo ponerla dentro de un
monitor

Tipo nombre-monitor = monitor;
Declaración de variables
Procedure entry P1(...);
Begin...end;
....
Procedure entry Pn(...);
Begin...end;
Begin
Código inicializació
Sintaxis de un monitor
NOTA
Asegura que solo un proceso a la vez puede estar activo dentro
del monitor.
El programador no necesita codificar explícitamente.
Se agrega el constructor condition para sincronización

Comunicación con mensajes
Definición:
Mensaje: parte de información que es pasada de un proceso a otro
Buzón: lugar donde se depositan los mensajes desde el envío a la recepción
Fuerza la exclusión mutua
Intercambio de información
Operaciones sobre mensajes:
send (destination, message)
receive (source, message)
Métodos de comunicación
Comunicación en un único sentido: los mensajes fluyen en un único sentido
Ejemplos: Tuberías de UNIX, productor-consumidor y streams
Comunicación bidireccional: los mensajes fluyen en ambos sentidos
Ejemplos: Llamadas a procedimientos remotos (RPC´s) o el modelo cliente-servidor

Ventaja: se puede implementar en sistemas distribuidos, en multiprocesador, y mono con memoria
compartida.
Comunicación con mensajes
Características de sincronización
Envío bloqueante, recepción bloqueante
El E y el R se bloquean hasta que se entrega el mensaje (Rendezvous).
Envío no bloqueante, recepcion bloqueante
El E puede continuar, pero R se bloquea hasta que llega el mensaje.
Envío no bloqueante, recepción no bloqueante
Nadie espera
El send no bloqueante es la forma mas útil en programación concurrente. Cuidado con la generación de
mensajes excesiva. El programador debe controlar la recepción.
El Envío no bloqueante, recepción bloqueante es útil para procesos servidores que ofrezcan servicio o
recursos a otros procesos

Ejemplos
• Productor:
int mensaje1[1000];
while (1)
{
--Preparamos el mensaje1--
enviar (mensaje1, buzón);
}
• Cliente:
char resp[1000];
envia(“leer vax”, buzon1);
recibir (resp, buzon2);
• Consumidor:
int mensaje2[1000];
while (1)
{
recibir (mensaje2, buzón);
--Procesamos el mensaje2--
}
• Servidor:
char orden[100];
char resp[1000];
recibir (orden, buzon1);
enviar (resp, buzon2);

Programacion concurrente

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Programacion concurrente

Similar a Programacion concurrente (20)

Más de puracastillo

Más de puracastillo (20)

Último

Último (20)

Programacion concurrente