SO Unidad 2: Mecanismos de comunicación y sincronización de procesos

Sistemas Operativos Carrera de Software
Ph.D. Franklin Parrales 1
25/03/2022
Material docente compilado por el profesor Ph.D. Franklin Parrales Bravo
para uso de los cursos de Sistemas Operativos
Mecanismos de
comunicación y
sincronización de procesos
Unidad 2

25/03/2022
Objetivo general de la Unidad 2
Caracterizar los mecanismos de sincronización y las
necesidades que surgen en el interbloqueo, mediante la
resolución de problemas de concurrencia, para llevar a
cabo la instalación, configuración y mantenimiento de los
sistemas operativos según requerimientos.

25/03/2022
Contenido
• Conceptos De Sincronización Y
Comunicación Entre Procesos.
• Sincronización Entre Procesos
(Tuberías, Semáforos, Mutex, Etc)
• Problemas Clásicos De
Concurrencia:
– El Peluquero Dormilón
– Problema De Lectores Y
Escritores,
– Problema Del Productor Y
Consumidor,
– Problema De Los Filósofos
Comensales.
• Interbloqueo
– Introducción a interbloqueos
– Detección y recuperación de
un interbloqueo
– Como evitar interbloqueos
– Como prevenir interbloqueos
– Comandos para
administración de procesos.
– Caracterización y
administración de la Sección
crítica de un proceso.

25/03/2022
Comunicación entre procesos
• Es necesaria la comunicación entre
procesos:
– Intercambiar información entre los procesos
– No interferir con actividades críticas de otros
procesos
– Secuencia correcta cuando existe
dependencia de información

25/03/2022
Concurrencia
• El acceso concurrente a datos compartidos puede
resultar en inconsistencias
• Mantener la consistencia de los datos requiere el
uso de mecanismos que aseguren la ejecución
ordenada de procesos que cooperan
• La concurrencia implica las siguientes cuestiones de
diseño:
– Comunicación entre procesos.
– Compartición y competencia por los recursos.
– Sincronización de la ejecución de varios procesos.
– Asignación del tiempo de procesador a los procesos.

25/03/2022
Coordinación de procesos
• Los procesos en algunos casos deben coordinarse y compartir
información.
• Los mecanismos de coordinación de procesos garantizan la
exclusión mutua para los recursos compartidos.
• Cuando un proceso está modificando un recurso compartido,
otros procesos no deberían poder cambiar ese recurso.
• Al diseñar el intercambio de información entre procesos, debe
tener en cuenta el hecho de que estos procesos pueden estar
funcionando a diferentes velocidades.
– Un proceso genera información; el otro proceso consume esa
información.
– Si el productor se ejecuta más rápido que el consumidor,
nueva información podría sobrescribir un ítem de información
leído previamente antes de que el proceso consumidor lea la
información original.
– Si el proceso consumidor se ejecuta más rápido que el
proceso productor, el mismo ítem podría leerse dos veces.

25/03/2022
Condiciones de Carrera
(race conditions)
• Problema
– Las condiciones de carrera se dan cuando:
• varios procesos accesan y manipulan los mismos
datos concurrentemente, y
• el resultado final depende del orden particular en
que los accesos se llevaron a cabo
• Solución
– Usar mecanismos de sincronización para que
solamente un proceso pueda manipular los
datos a la vez

25/03/2022
Ejemplo de actualizaciones en conflicto sobre BDs
Una clásica condición de carrera (Race Condition)
Réplica 1
Initially x=0
T1: X=1
Primary
Initially x=0
Send (X=1)
Réplica 2
Initially x=0
T2: X=2
Send (X=1)
X=1
X=1
X=2
Send (X=2)
X=2
Send (X=2)
• Las réplicas terminan en diferentes estados

25/03/2022
Ejemplo de variable compartida con
condición de carrera
thread A:
run() { v = v + 1; }
thread B:
run() { v = v * 2; }
v = 5
v = 12 v = 11
RMW issues
Read-Modify-Write
v = 6 v = 10

25/03/2022
Ejemplo de variable compartida con
condición de carrera
thread A:
run() { v = v + 1; }
thread B:
run() { w = v * 2; }
v = 5
v = 6
w = 12
v = 6
w = 10
RMW issues
Read-Modify-Write

25/03/2022
Sección Crítica
• Zonas críticas
– secciones del programa que sólo debe ejecutar un
thread en un momento dado, o habría problemas
• Protocolo
– si está ocupado, espero
– si está libre
• Entro
– cierro por dentro
• hago mis cosas – yo solito
• Salgo
– dejo abierto
– si hay alguien esperando, que entre
– si no, queda abierto
java mantiene una cola de
threads esperando
a que el cerrojo(lock) se abra
todo esto es indivisible
ATÓMICO

25/03/2022
Operación atómica
– la que se ejecuta sin cambiar de thread
– ejemplo
• int n = v++;
NO es atómica => posibles carreras
– solución: envolverla
– véase AtomicInteger
class IntAtomico {
private int v;
synchronized int inc() {
v++;
return v;
}
}
IntAtomico va = new IntAtomico();
int n = va.inc();

25/03/2022
AtomicInteger
• java.util.concurrent.atomic
• AtomicInteger class AtomicCounter {
private AtomicInteger c = new AtomicInteger(0);
public void increment() {
c.incrementAndGet();
}
public void decrement() {
c.decrementAndGet();
}
public int value() {
return c.get();
}

25/03/2022
Estados de un thread(hilo o hebra)
new Thread()
NEW
start()
RUNNABLE
BLOCKED
WAITING
TIMED WAITING
TERMINATED

25/03/2022
Problema de la Sección Crítica
1. Exclusión mutua: Si el proceso Pi está
ejecutando su sección crítica, ningún otro
proceso puede estar ejecutando la suya
2. Progreso: Si ningún proceso está ejecutando su
sección crítica y existe algún otro proceso que
desea entrar a la suya, entonces ese proceso no
puede posponerse indefinidamente
3. Espera limitada: Debe haber un límite en el
número de veces que otros procesos pueden
entrar a sus secciones críticas después de que
un proceso a solicitado entrar a la suya, y antes
de que se le otorgue el acceso a ese proceso

25/03/2022
Problema de la Sección Crítica (cont.)
• Condición de carrera: Cuando hay acceso
concurrente a datos compartidos y el
resultado final depende del orden de
ejecución
• Sección crítica: Sección de código en donde
se accesa a los datos compartidos
• Sección de entrada: Código que solicita el
permiso para entrar a su sección crítica
• Sección de salida: Código que se ejecuta al
salir de la sección crítica

25/03/2022
Estructura de un Proceso Típico

25/03/2022
Exclusión mutua
• Para evitar el acceso simultaneo a la sección crítica se
emplean mecanismos que garantizan la exclusión mutua.
• La exclusión mutua se debe realizar de forma coordinada y
eficiente, para ello se requiere:
• No más de un proceso por sección crítica y recurso compartido.
• El mismo proceso no puede usar el mismo recurso compartido
indefinidamente.
• Todo proceso debe entrar antes o después a usar el recurso.
• Si el recurso está sin uso, cualquiera que lo requiera dispondrá
de él inmediatamente.
• Si hay varios esperando usar el recurso y éste se libera, uno de
los que estaba esperando lo usará durante un tiempo
determinado.
• Para llevar esto a cabo se necesita un protocolo que indique
cuando el recurso está libre y cuando está siendo ocupado.

25/03/2022
Exclusión mutua
• Los procesos productores recopilan datos y los agregan al
búfer. Los procesos de consumo toman datos del búfer y
hacen que los elementos estén disponibles.
• Los procesos productores y consumidores deben estar
mutuamente excluidos del acceso al mismo elemento.
• El búfer debe detener los procesos de producción que
agregan información a un búfer lleno y los procesos de
consumo que intentan tomar información de un búfer vacío.
• Para solucionar este problema, se debe implementar
intercambio de información mediante un buffer compartido y
usar mecanismos de exclusión mutua para controlar el
acceso a ese buffer.
– Esto significa que la información no puede sobrescribirse
antes de leerse y que la información no debe leerse dos
veces

25/03/2022
Procesos de productor / consumidor que
comparten un buffer circular
Proceso
consumidor
Proceso
productor
Final
Inicio
Buffer circular
• El proceso productor siempre ingresa datos al final de la cola.
• El proceso consumidor siempre recupera datos del inicio de la cola.
• Las primitivas de sincronización, como los semáforos o las regiones críticas, se
usan para asegurar que las operaciones de Get y Put están sincronizadas, de
manera que no accedan a la misma ubicación al mismo tiempo.
• Por lo general, el
buffer compartido se
implementa como una
cola circular.
• Así, la falta de
concordancia de
velocidades entre los
procesos productor y
consumidor pueden
acomodarse sin tener
que demorar la
ejecución del proceso.

25/03/2022
Tipos de mecanismos de
sincronización
• Los mecanismos de sincronización los podemos catalogar en dos
categorías:
• Optimistas: Este mecanismo considera que la frecuencia de acceso a
un cierto recurso compartido es baja. Este tipo tiene más consumo de
memoria, ya que tiene que copiar el recurso compartido y, en caso de
interferencia en el hilo, tiene que volver a ejecutarlo y consume más
recursos.
• Pesimistas: Este mecanismo permite coordinar la ejecución de dos o
más procesos que acceden al recurso compartido con una
frecuencia alta.
• Dependerá del criterio del programador el tipo de mecanismo que
utilice ya que puede que no elija el tipo correcto. Por ejemplo,
puede que la frecuencia de acceso a un cierto recurso sea alta y el
programador le asigna un mecanismo optimista, esto provocaría no
obtener el resultado esperado.

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Tuberías
◼ Mecanismo de comunicación y sincronización
ls –l | cut –c1 | sort
ls -l tubo1
Pares turnoPar Impares
cut –c1 tubo2 sort
3, 2, 1 3+2+1

25/03/2022
Tuberías
◼ “Pseudo-archivo” manejado por el SO.
◼ Cada proceso ve a la tubería como un conducto con dos extremos:
◆ Uno para escribir o insertar datos.
◆ Otro para leer o extraer datos.
◼ La lectura/escritura de datos se realiza mediante los servicios de
lectura/escritura de archivos.
◼ Flujo de datos unidireccional y FIFO.
◼ Para un flujo de datos bidireccional hay que crear dos tuberías.
Proceso A Proceso B
write read
SO
Tubería

25/03/2022
Tuberías
◼ Tipos de tuberías:
◆ Sin nombre: Sólo pueden usarla procesos que desciendan del proceso
que la creó.
◆ Con nombre: Pueden usarla procesos independientes.
◼ Servicios POSIX:
◆ Creación de tuberías sin nombre:
int pipe (int tub[2]);
◆ Creación de tuberías con nombre:
int mkfifo (char *fifo, mode_t mode);

25/03/2022
Tuberías
◼ Escritura en una tubería:
◆ Introduce datos en orden FIFO.
◆ Operación atómica.
◆ Si la tubería está llena o se llena durante la escritura, la
operación bloquea al proceso escritor hasta que se pueda
completar.
◆ Si no hay ningún proceso con la tubería abierta para lectura, la
operación devuelve error.

25/03/2022
Tuberías
◼ Lectura de una tubería:
◆ Obtiene datos (y los elimina de la tubería).
◆ Operación atómica.
◆ Si la tubería está vacía, la llamada bloquea al proceso en la
operación de lectura hasta que algún proceso escriba datos en la
misma.
◆ Si la tubería almacena M bytes y se quieren leer n bytes:
⚫ Si Mn, se devuelven y eliminan n bytes.
⚫ Si M<n, se devuelven y eliminan M bytes.
◆ Si no hay escritores y la tubería está vacía, la operación
devuelve fin de archivo.

25/03/2022
Tuberías: Función pipe
◼ Sintaxis:
int pipe(int descriptor[2]);
devuelve:
◆ Si todo ha ido bien: 0
◆ Si error: -1
◼ Descripción:
◆ Crea una tubería sin nombre
⚫ Lectura de datos de la tubería vía
⚫ Escritura de datos en la tubería vía
descriptor[0]
descriptor[1]
◼ Ejemplo:
◆ int tuberia[2];
pipe (tuberia);

25/03/2022
Tuberías: Función pipe
◼ Lectura de una tubería:
◆ read bloquea al proceso que la realiza hasta que:
⚫ Existe algún dato por leer ó
⚫ Se ha alcanzado el final de fichero
◼ Fin de fichero de una tubería:
◆ Cuando se cierran todos los descriptores de entrada (escritura) a esa
tubería
Deben cerrarse los descriptores de tubería que no vayan a ser usados
◼ Comunicación de padre e hijo mediante una tubería:
◆ pipe antes de fork

25/03/2022
Arquitecturas de sincronización en Java
• no estructuradas
– locks
– Semáforos
– barreras
• estructuradas
– bloques synchronized
– métodos synchronized
– monitores

25/03/2022
Lock (candado o cerrojo)
• Un cerrojo proporciona exclusión mutua en el acceso
a datos compartidos.
• El cerrojo es una variable de dos estados (libre y
ocupado) y tiene dos operaciones públicas:
– Acquire (lock)– Espera a que el cerrojo esté libre y lo
adquiere.
– Release (unlock)– Libera el cerrojo; si había alguien
esperando en Acquire, se lo entrega a alguno de los
procesos que esperan.
• Inicialmente, se considera que el cerrojo está libre. Un
cerrojo puede ser considerado como un semáforo
binario inicializado a true.
• Para acceder a datos compartidos en exclusión
mutua, se usa un cerrojo. Antes de usar los datos
compartidos se llama a Acquire y tras manipular los
datos, se libera el cerrojo con Release

25/03/2022
Lock (candado o cerrojo)
• el mecanismo de cerrojos alrededor de zonas
de acceso exclusivo
– es un mecanismo pesimista
• siempre me protejo por si acaso
– puede hacer que una thread quede esperando a
que otra termine
• si la otra casca, puede esperar eternamente
• puede ser que una tarea de alta prioridad quede
esperando a que termine otra de menor prioridad
– priority inversión

25/03/2022
Priority inversión
• C (prioridad baja) cierra un lock
• A (prioridad alta) quiere el lock que tiene C
• B (prioridad media) monopoliza la cpu
• resultado
– B se lo lleva todo mientras A espera tontamente
ej: https://en.wikipedia.org/wiki/Mars_Pathfinder

25/03/2022
Continuando con… Lock (candado o cerrojo)
Un ReentrantLock es un mecanismo de exclusión mutua
que permite que los subprocesos vuelvan a entrar en un lock
sobre un recurso (varias veces) sin una situación de
interbloqueo.
• package java.util.concurrent.locks
– interface Lock
– class ReentrantLock implementa Lock
• OJO:
– hay que asegurarse de que se libera el cerrojo; por
ejemplo, si hay excepciones
lock.lock();
... operaciones ...
lock.unlock();
try {
lock.lock();
zona exclusiva
} finally {
lock.unlock();
}

25/03/2022
Lock: estado compartido protegido
public class Contador {
private int cuenta = 0;
private final Lock LOCK = new ReentrantLock();
nadie puede
meterse
por enmedio estado protegido
public int incrementa(int v) {
try {
LOCK.lock();
cuenta += v;
return cuenta;
} finally {
LOCK.unlock();
}
}
public int decrementa(int v) {
try {
LOCK.lock();
cuenta -= v;
return cuenta;
} finally {
LOCK.unlock();
}
}

25/03/2022
Lock: atomicidad
• las operaciones lock() y unlock()
son indivisibles
– no se permite que un thread se vea desplazado
por otro mientras se están ejecutando
• esta misma propiedad sirve para todas las
formas de sincronización:
– semáforos y bloques sincronizados

25/03/2022
Lock: Variables de Condición
Lock cerrojo;
InsertaEnCola() {
cerrojo.Acquire();
añade un elemento en la cola;
cerrojo.Release();
}
ExtraeDeCola() {
cerrojo.Acquire();
if (algo en la cola)
extrae(cosa);
cerrojo.Release();
return cosa;
}
v1
v2
v3
Proceso productor
Proceso consumidor
La rutina ExtraeDeCola() debería esperar a que hubiera algún elemento en la cola.
• Si lo que hacemos es sleep(dormir) al hilo hasta que alguien deposite un
elemento en la cola, resulta que el programa se bloquea, ya que al estar retenido
el cerrojo, ningún otro hilo puede manipular la cola.
• Por tanto hay que liberar el cerrojo antes de esperar.

25/03/2022
Variables de Condición
• Como vemos, el ejemplo de
la cola circular nos muestra
un problema que los cerrojos
no son capaces de resolver.
• Una posible solución sería…
ExtraeDeCola() {
cerrojo.Acquire();
while (cola vacía) {
cerrojo.Release();
cerrojo.Acquire();
}
extrae(cosa);
cerrojo.Release();
return cosa;
}
Esta solución funciona, pero utiliza espera
activa: el hilo está continuamente entrando
y saliendo de la sección crítica para revisar
si la cola está vacía.

25/03/2022
• La idea de las variables condición es tener un
mecanismo que permita a un proceso
– abandonar una sección crítica y a la misma vez
– quedarse bloqueado en espera de una condición que alguien le
debe notificar.
• Variable condición: representa una cola de hilos que
esperan algo (una condición) dentro de una sección
crítica (indicada por un cerrojo).
• Hay dos operaciones posibles:
– x.wait() – un proceso que invoca la operación es suspendido
– x.signal() – se continúa a uno de los procesos que invocaron
x.wait()
• Sólo se permite trabajar con una variable condición si
disponemos del cerrojo.

25/03/2022
• La solución al problema de la cola, con variables de
condición, tendría esta forma:
Lock cerrojo;
Condition condición;
InsertaEnCola() {
cerrojo.Acquire();
condición.signal(&cerrojo); // avisamos de que hay algo
cerrojo.Release();
}
ExtraeDeCola() {
cerrojo.Acquire();
while (cola vacía)
condición.Wait(&cerrojo); // nos bloqueamos hasta que nos
// hagan signal()
extrae(cosa);
cerrojo.Release();
return cosa;
}

25/03/2022
Lock cerrojo;
InsertaEnCola() {
cerrojo.Acquire();
condición.signal(&cerrojo);
cerrojo.Release();
}
ExtraeDeCola() {
cerrojo.Acquire();
while (cola vacía)
condición.Wait(&cerrojo);
extrae(cosa);
cerrojo.Release();
return cosa;
}
v4
Proceso productor
Proceso consumidor
signal

25/03/2022
RentrantLock con variables de
condición
Una variable de condición se crea la primera vez que se
crea un ReentrantLock y se invoca su newCondition() :
Luego, se puede invocar sus métodos wait() y signal()
entre lock y unlock

25/03/2022
RentrantLock con variables de
condición
• colas dentro de un cerrojo
15
public void InsertaEnCola(E x)
throws InterruptedException {
lock.lock();
while (data.size() >= SIZE)
isFull.await();
data.add(x);
isEmpty.signalAll();
lock.unlock();
}
public E ExtraeDeCola()
lock.lock();
while (data.isEmpty())
isEmpty.await();
E value = data.remove(0);
isFull.signalAll();
lock.unlock();
return value;
}
private Lock lock = new ReentrantLock();
private Condition isEmpty = lock.newCondition();
private Condition isFull = lock.newCondition();
private final List<E> data = new ArrayList<>(size);

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Semáforos
• Otro mecanismo que pueden utilizar los
threads para proteger secciones de código
son los semáforos.
• Las operaciones principales son:
– esperar a que el contador sea distinto de 0 y le
resta 1 al contador antes de continuar sumar 1 al
contador
– Si el contador es 0 indicará que el thread no
puede acceder a la sección crítica, y
– Si es >0, podrán acceder tantos threads como
valor tenga el contador.

25/03/2022
Semáforos
Semáforos

25/03/2022
Semáforos
• package java.util.concurrent
– class Semaphore
• Semaphore (int permisos)
• semáforo binario: gestiona 1 permiso de acceso
– void acquire()
– void release()
• semáforo general: gestiona N permisos
– void acquire(int n)
• solicita N permisos del semáforo
si no hay bastantes, espero
• cuando los haya, sigo
– void release(int n)
• devuelvo N permisos al semáforo
• si hay alguien esperando, se intenta satisfacerle

25/03/2022
Semáforo binario
semaforo.acquire();
... operaciones ...
semaforo.release();
semaforo.acquire();
try {
... operaciones ...
} finally {
semaforo.release();
}

25/03/2022
Semáforo binario
• Correcto uso de operaciones:
– semaforo.acquire() …. semaforo.release()
• Mal uso de operaciones:
– semaforo.acquire() … semaforo.acquire()
– Omitir semaforo.acquire() o
semaforo.release() (o ambos)

25/03/2022
Uso de los semáforos
1. limitar el número de threads en la zona crítica
16
Semaphore sm = new Semaphore(5) # Max: 5-threads
InputStream fetch_page(String ref):
sm.acquire();
try {
URL url = new URL(ref);
return url.openStream();
} finally {
sm.release();
}
Semaphore semaphore = new Semaphore(N)
semaphore.acquire();
try {
… zona crítica …
} finally {
semaphore.release();
}

25/03/2022
Uso de los semáforos
2. coordinar threads
thread_1
stmt_1;
stmt_2;
done.release();
stmt_3;
stmt_4;
Semaphore done = new Semaphore(0)
thread_2
stmt_1;
stmt_2;
done.acquire();
stmt_3;
stmt_4;

25/03/2022
Ejemplo de Semáforo
public class Parking {
private final int capacidad; // número de coches que caben
private final Semaphore semaphore;
// constructor
public ParkingSemaphore(int capacidad) {
this.capacidad = capacidad;
semaphore = new Semaphore(capacidad);
}
// barreras de entrada
public void entra() throws InterruptedException {
semaphore.acquire(1);
}
// barreras de salida
public void sale() {
semaphore.release(1);
}

25/03/2022
Ejemplo de semáforo con N permisos
public class EsperaNTareas {
public static void main(String[] args)
Semaphore contador = new Semaphore(0);
List<Tarea> tareas = new ArrayList<Tarea>();
tareas.add(new Tarea(contador));
// ... N veces
for (Tarea tarea : tareas)
tarea.start();
// espera a que todas acaben
contador.acquire(tareas.size());
}
}

25/03/2022
Ejemplo de semáforo con N permisos
public class Tarea extends Thread {
private Semaphore contador;
public Tarea( Semaphore contador ){
this.contador = contador;
}
public void run() {
// hace su tarea
contador.release();
}
}

25/03/2022
Semáforos vs. Variables de condición
• Una diferencia fundamental entre
semáforos y variables condición es que
éstas no tienen memoria.
– En las variables de condición, si alguien
ejecuta una operación signal sin que nadie
haya estado esperando, esa operación se
pierde para siempre,
– mientras que en un semáforo se “recuerda”
para posteriores waits.

25/03/2022
Semáforos vs. ReentrantLock
• Ningún thread es propietario de un semáforo
binario.
– Sin embargo, el último thread que bloqueó(locked)
correctamente un recurso es el propietario de un
reentrantLock.
• Un semáforo binario proporciona un mecanismo
de sincronización de alto nivel al permitir una
implementación personalizada de un mecanismo
de bloqueo y recuperación de interbloqueos. Por
lo tanto, da más control a los desarrolladores.
– Sin embargo, el reentrantLock es un mecanismo de
sincronización de bajo nivel con un mecanismo de
bloqueo fijo(fixed locking).

25/03/2022
Semáforos vs. ReentrantLock (cont…)
• Los semáforos binarios proporcionan un
mecanismo de liberación no apropiativa.
– Por lo tanto, cualquier subproceso puede liberar el
permiso para la recuperación de un interbloqueo
de un semáforo binario.
• Por el contrario, la recuperación de
interbloqueo es difícil de lograr en el caso de
un ReentrantLock.
– Por ejemplo, si el subproceso propietario de un
ReentrantLock entra en modo de suspensión o
espera infinita, no será posible liberar el recurso y
se producirá una situación de interbloqueo.

25/03/2022
Comentarios sobre locks y semáforos
• son de bajo nivel
• primitivas independientes
• requieren que todos colaboren
• se puede hacer cualquier cosa, esten bien
o no
– abrir y cerrar no están necesariamente
emparejados sintácticamente

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Barreras
• Este mecanismo de sincronización está
destinado a los grupos de procesos
• Algunas aplicaciones se dividen en fases y
tienen la regla de que ningún proceso puede
continuar a la siguiente fase sino hasta que
todos los procesos estén listos para hacerlo.
• Para lograr este comportamiento, se coloca
una barrera al final de cada fase.
• Cuando un proceso llega a la barrera, se
bloquea hasta que todos los procesos han
llegado a ella.

25/03/2022
Barreras
• La operación de una barrera se ilustra en la figura
Uso de una barrera. (a) Procesos que se acercan a una barrera. (b) Todos
los procesos menos uno bloqueados en la barrera. (c) Cuando el último
proceso llega a la barrera, se deja pasar a todos.
Barrera
A
B
C
D
Proceso
Tiempo
(a)
Barrera
A
B
C
D
Tiempo
(b)
Barrera
A
B
C
D
Tiempo
(c)

25/03/2022
Barreras en java: CyclicBarrier
• CyclicBarrier(int required)
– Una sincronización que permite que un conjunto
de subprocesos esperen unos a otros para llegar
a un punto de barrera común.
• void await()
versión con código a ejecutar cuando se abre
• CyclicBarrier(int parties, Runnable action)

25/03/2022
Barreras en java: CyclicBarrier
coordinar threads
CyclicBarrier barrier = new CyclicBarrier(3)
thread_1
block_11();
barrier
.await();
block_12();
barrier
.await();
block_13();
barrier
.await();
thread_2
block_21();
barrier
.await();
block_22();
barrier
.await();
block_23();
barrier
.await();
thread_3
block_31();
barrier
.await();
block_32();
barrier
.await();
block_33();
barrier
.await();

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Sincronización en Java
• Java proporciona sincronización a nivel del
lenguaje
• Cada objeto en Java tiene asociado un lock
– Se adquiere al invocar un método synchronized
– Se libera cuando se sale del método synchronized
• Hilos que esperan por adquirir un objeto lock se
colocan en el entry set (conjunto de espera)
para ese objeto lock
Cada objeto tiene
asociado un entry set.

25/03/2022
Sincronización en Java (cont.)
Métodos insert() y remove() synchronized
¿Problemas?

25/03/2022
Sincronización en Java: wait/notify()
• Cuando un hilo invoca wait():
1. El hilo libera el objeto lock
2. El estado del hilo se coloca en Blocked
3. El hilo se coloca en el wait set del objeto
• Cuando un hilo invoca notify():
1. Un hilo arbitrario del wait set se selecciona
2. T se mueve del wait set al entry set
3. El estado de T se coloca en Runnable
Entry set y wait set

25/03/2022
Sincronización en Java (cont.)
• Llamar a notify() selecciona un hilo arbitrario del
wait set
– Es posible que el hilo seleccionado no esté esperando
por la condición por la que ha sido notificado
• La llamada a notifyAll() selecciona todos los
hilos en el wait set y los mueve a todos al entry
set
• En general notifyAll() es una estrategia más
conservadora que notify()

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Bloques synchronized
• synchronized (objeto) {
// zona de exclusión mutua
}
synchronized (cc) {
... operaciones ...
}
cc: Object compartido
el cerrojo se libera al salir del
bloque:
• última sentencia
• return interno
• excepción

25/03/2022
Estado compartido protegido
private final Object LOCK = new Object();
public int incrementa(int v) {
synchronized (LOCK) {
cuenta += v;
return cuenta;
}
}
public int decrementa(int v) {
synchronized (LOCK) {
cuenta -= v;
return cuenta;
}
}

25/03/2022
Bloques Mutex
• Un mutex es un dispositivo de exclusión mutua
útil para proteger estructuras de datos
compartidas de modificaciones concurrentes, y
para implementar secciones críticas y monitores.
• Los mutex tienen dos estados posibles:
– Unlocked/release (libre, no ocupado por ningún
thread) o
– Locked/acquire (ocupado por un thread).
• Un mutex nunca puede estar ocupado por más de
un thread
• Si un thread intenta ocupar un mutex ya ocupado,
quedará a la espera de que el thread que tienen el
mutex lo libere.

25/03/2022
Bloques Mutex
• Los mutex permiten bloquear una parte del
código, de forma que ningún otro hilo de
ejecución pueda accederla mientras no se
libere el bloqueo.
• De esta forma, si los threads bloquean el
código que comprueba el número de
entradas que quedan y lo liberan después de
realizada la venta, obligamos a que primero
se ejecute la parte crítica un proceso y luego
la otra.

25/03/2022
Bloques Mutex
En lugar de sincronizar todo un método, se puede
sincronizar bloques de código

25/03/2022
Bloques Mutex
Sincronización de bloques usando wait()/notify()

25/03/2022
¿Mutex es un semáforo binario?
• Se suele decir que mutex es un
semáforo binario que garantiza la
exclusión mutua en las operaciones que
se ejecutan sobre el semáforo
general…¡Pero no lo es!
• El propósito de mutex y semáforo es
diferente. Tal vez, debido a la similitud en
su implementación, un mutex podría
parecerse a un semáforo binario.

25/03/2022
¿Mutex es un semáforo binario?
Mutex
• Estrictamente hablando, un
mutex es un mecanismo de
bloqueo utilizado para
sincronizar el acceso a un
recurso.
– Solo una tarea (puede ser un
subproceso o un proceso
basado en la abstracción del
sistema operativo) puede
adquirir la exclusión mutua.
• Significa que hay propiedad
asociada con un mutex, y solo
el propietario puede liberar el
bloqueo (mutex).
Semáforos
• El semáforo es un mecanismo
de señalización (señales del
tipo "Terminé, puedes
continuar…").
– Por ejemplo, si está
escuchando canciones
(suponga que es una tarea) en
su teléfono móvil y, al mismo
tiempo, su amigo lo llama, se
activa una interrupción en la
que una rutina de interrupción
de servicio(ISR) señala
despertar(wakeup) la tarea de
procesamiento de llamadas.

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Métodos synchronized
• usando this como cerrojo
– es lo mismo…
pero escribes menos y te equivocas menos
public synchronized int incrementa(int v) {
cuenta += v;
return cuenta;
}
public synchronized int decrementa(int v) {
cuenta -= v;
return cuenta;
}

25/03/2022
Comentarios sobre bloques y métodos
synchronized
• son de alto nivel
• delimitan una zona
• requieren que todos colaboren
• un thread que ya posee un cerrojo puede entrar
en zonas protegidas por el mismo cerrojo
– esto permite que un método synchronized llame a
otro método synchronized

25/03/2022
– locks
– Semáforos
– barreras
• estructuradas
– monitores

25/03/2022
Monitores
• clases donde
– se monitoriza toda modificación del estado
• el estado es privado
• todos los accesos son zonas críticas
• en java
– todos las campos son privados
– todos los métodos son synchronized

25/03/2022
Monitores: Ejemplo
public synchronized int getCuenta() {
return cuenta;
}
public synchronized int incrementa(int v) {
cuenta += v;
return cuenta;
}
public synchronized int decrementa(int v) {
cuenta -= v;
return cuenta;
}
}
synchronized garantiza
•
•
acceso exclusivo
variables actualizadas

25/03/2022
Monitores
• Abstracción de alto
nivel que proporciona
un mecanismo efectivo
y conveniente para la
sincronización entre
procesos
• Solo un proceso puede
estar activo dentro del
monitor en un
momento dado
Sintaxis de un Monitor

25/03/2022
Esquema de un Monitor

25/03/2022
Monitores
• SO provee semáforos o mutexes.
• Lenguaje provee enunciados para monitores.
• Compilador usa primitivas del SO para
traducir los procedimientos del monitor de tal
manera que se considere la exclusión mutua.
• Programador no se preocupa de codificar
semáforos
• Programador sólo debe incluir las secciones
críticas como parte de un procedimiento de
monitor.

25/03/2022
Monitor y Variable de condición
• Los procedimientos en un monitor se pueden
llamar siempre considerando la exclusión
mutua.
• Existe acceso coordinado a buffers y
variables compartidos.
• Pero como un proceso puede ir a sleep si no
pudiera continuar?
– Si necesitara que se complete un evento
– Tal vez este evento debe ser generado por otro
proceso.

25/03/2022
Monitor y Variable de condición (cont…)
• Solución:
– Uso de variables de condición, y
– Uso de operaciones wait() y signal() en esas
variables
• Si un proceso necesita bloquearse:
– (Por ejemplo, buffer está lleno y productor no
debe colocar más información)
– Proceso llama wait() en alguna variable de
condición x.

25/03/2022
Monitor y Variable de condición (cont…)
• Cuando otro proceso quiere desbloquear
al proceso que está durmiendo:
– (por ejemplo?).
– El proceso llama signal() en la misma variable
de condicion x.
• Las variables de condición NO SON
CONTADORES.
– No almacenan señales signal.
– signal() debe ser llamado después de wait().

25/03/2022
Monitor con Variables de Condición

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Tarea grupal
• Para cada uno de los siguientes
problemas se requiere escribir un
programa con interfaz gráfica que
atienda las necesidades que presenta
cada uno de estos, aplicando la solución a
la administración de procesos que hemos
visto hasta ahora.

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
El Peluquero Dormilón
• El problema consiste en programar a un barbero y
a sus clientes sin entrar en competencia
• La peluquería tiene un barbero, una silla de
peluquero y n sillas para que se sienten los
clientes en espera, si es que los hay.

25/03/2022
El Peluquero Dormilón
• Si no hay clientes el barbero se sienta en la
silla de peluquero y se duerme. Cuando llega
un cliente debe despertar al barbero.
• Si llegan más clientes mientras el barbero
corta el cabello a un cliente, ellos se sientan
(si hay sillas desocupadas).
• Un cliente que entra a la peluquería debe
contar el número de clientes que esperan. Si
es menor que el número de sillas, él se
queda; en caso contrario se va.

25/03/2022
Una solución…
• Cuando el barbero abre su negocio se debe ejecutar
un semáforo denominado barber que chequea el
número de barberos en espera de clientes (0 o 1), lo
que establece un bloqueo en otro semáforo: customer,
que cuenta el número de clientes en espera, después
se va a dormir.
• Cuando llega el primer cliente, éste ejecuta customer,
que inicia procurando que un tercer semáforo llamado
mutex entre en una región crítica. Mutex se va a
utilizar para la exclusión mutua.
• Si otro cliente llega, no podrá hacer nada hasta que el
primero haya liberado a mutex.

25/03/2022
Una solución…
• El cliente verifica entonces si el número de
clientes que esperan es menor que el número de
sillas. Si esto no ocurre, libera a mutex y sale sin
su corte de pelo.
• Si existe una silla disponible, el cliente incrementa
la variable entera waiting, que es una replica de
customer. Después realiza un “levantamiento” en
customer, con lo que despierta al barbero.
• Cuando el cliente libera a mutex, el barbero lo
retiene, ordena algunas cosas e inicia el corte de
pelo.

25/03/2022
Una solución…
• Al terminar el corte, el cliente sale del
procedimiento y deja la peluquería.
• Nótese que no existe un ciclo para el
cliente, puesto que el corte de pelo es una
actividad que el cliente recibe
automáticamente, más no ejecuta tal
actividad.

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Problema De Lectores Y Escritores
• Se utiliza para modelar el acceso a una base de datos
• Cuando se tiene una enorme base de datos, como por
ejemplo un sistema de reservaciones de una
aerolínea, con muchos procesos en disputa por la
escritura o lectura a dicha base. ¿Cómo se deben
programar los lectores y los escritores?.
• Una solución es dar en primera instancia prioridad
primaria a los lectores y secundaria a los escritores,
es decir, si existen lectores el escritor debe esperar
hasta que ya no haya lectores.
• En segunda instancia, cuando el escritor tome
prioridad primaria los lectores deben esperar a que el
escritor termine su función.

25/03/2022
Problema de los Lectores-Escritores
• Un conjunto de datos se comparte entre un #
concurrente de procesos
– Lectores – solo leen datos
– Escritores – pueden leer y escribir
• Problema – permitir que múltiples lectores lean al
mismo tiempo; solo un escritor puede tener
acceso a los datos a la vez
• Datos compartidos
– Conjunto de datos
– Semáforo mutex inicializado en 1
– Semáforo db inicializado en 1
– Entero readerCount inicializado en 0

25/03/2022
Problema de los Lectores-Escritores (cont.)
Interfaz para los locks de lectura-escritura

25/03/2022
Métodos llamados por escritores

25/03/2022
• Estructura de un proceso escritor

25/03/2022
• Estructura de un proceso lector

25/03/2022
Sincronización en Java: Lectores-Escritores

25/03/2022
Sincronización en Java: Lectores-Escritores (cont.)
Métodos llamados por lectores

25/03/2022
Sincronización en Java: Lectores-Escritores (cont.)
Métodos llamados por escritores

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Problema de Productor-Consumidor
• Paradigma para procesos que cooperan
– Proceso productor produce información que
será consumida por proceso consumidor
• Variantes
– Buffer-ilimitado no coloca límites en el tamaño
del buffer
– Buffer-limitado asume que el buffer tiene un
tamaño fijo

25/03/2022
Buffer limitado
Proceso
consumidor
Proceso
productor
Final
Inicio
Buffer circular

25/03/2022
• Suponga que queremos proporcionar una
solución al problema de productor-
consumidor con buffer limitado
– Podemos hacerlo teniendo un entero count
que registra el # elementos en el buffer
– Inicialmente, count = 0
– El productor incrementa count luego de
producir un elemento
– El consumidor decrementa count luego de
consumir del buffer

25/03/2022
Productor
Consumidor

25/03/2022
Condiciones de Carrera
• count++ puede ser implementado como:
register1 = count
register1 = register1 + 1
count = register1
• count- - puede ser implementado como:
register2 = count
register2 = register2 - 1
count = register2
• Considere este entrelazado de la ejecución en el cual, inicialmente
“count = 5”:
S0: productor ejecuta register1 = count {register1 = 5}
S1: productor ejecuta register1 = register1 + 1 {register1 = 6}
S2: consumidor ejecuta register2 = count {register2 = 5}
S3: consumidor ejecuta register2 = register2 - 1 {register2 = 4}
S4: productor ejecuta count = register1 {count = 6 }
S5: consumidor ejecuta count = register2 {count = 4}

25/03/2022
Buffer Limitado mediante Sincronización

25/03/2022
Buffer Limitado mediante Sincronización (cont.)

25/03/2022
Problema del Buffer-Limitado mediante semáforo
• Buffer de tamaño N
• Semáforo mutex inicializado en 1
• Semáforo full inicializado en 0
• Semáforo empty inicializado en N

25/03/2022
Problema del Buffer-Limitado mediante semáforo
(cont.)

25/03/2022
Problema del Buffer-Limitado mediante
semáforo (cont.)

25/03/2022
Problema del Buffer-Limitado: Productor

25/03/2022
Problema del Buffer-Limitado: Consumidor

25/03/2022
Problema del Buffer-Limitado: Fábrica

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Problema De Los Filósofos
Comensales
• Este problema es útil para
modelar procesos que están en
competencia por el acceso
exclusivo a un número limitado de
recursos
• Este problema se puede enunciar
de la siguiente manera:
– Cinco filósofos se sientan a la
mesa. Cada uno tiene un plato de
espagueti.
– El espagueti es tan escurridizo,
que un filósofo necesita dos
tenedores para comerlo.
– Entre cada dos platos hay un
tenedor.

25/03/2022
Comensales
• La vida de un filósofo consta de dos periodos
alternados de comer y pensar. (Esto es una
abstracción, incluso para los filósofos, pero las
demás actividades son irrelevantes en este caso).
• Cuando un filósofo tiene hambre, intenta obtener
un tenedor para su mano izquierda y otro para su
mano derecha, alcanzando uno a la vez y en
cualquier orden.
• Si logra obtener los dos tenedores, come un rato y
después deja los tenedores y continúa pensando.

25/03/2022
Comensales
• Una solución es esperar hasta que el tenedor
especificado este disponible y tomarlo. Esta
solución es incorrecta si se hace la suposición de
que los cinco filósofos toman sus tenedores
izquierdos en forma simultánea. Ninguno de ellos
podría tomar su tenedor derecho, con lo que
ocurriría un bloqueo.
• Al volver a colocar los tenedores en la mesa,
ninguno estaría comiendo por lo que intentarían
volver a tomarlos y esta situación se repetiría
indefinidamente y es lo que se denomina como
inanición.

25/03/2022
Comensales
• Otra solución es esperar un cierto tiempo arbitrario, en
lugar del mismo tiempo, después de que no pudiesen
tomar el tenedor derecho y así reducir a un mínimo la
probabilidad de inanición pero hay ciertas aplicaciones
críticas que requieren funcionalidad total que esta
solución no proporciona.
• Una mejora de las soluciones anteriores es utilizar un
semáforo para indicar que recurso se tiene en uso.
Esto solo permite tener a un filósofo con dos
tenedores.
• Si un filósofo requiere comer debe verificar si a los
lados no se están utilizando los dos tenedores,
obteniendo así la solución más viable para este
problema.

25/03/2022
Problema de la Cena de Filósofos
• Datos compartidos
– Tazón de arroz (conjunto de datos)
– Semáforo chopStick [5] inicializado en 1
• Filósofos pueden comer(eating) o
pensar(thinking)

25/03/2022
Problema de la Cena de Filósofos (cont.)
• Estructura del filósofo i:

25/03/2022
Solución al Problema de la Cena de Filósofos

25/03/2022
Solución al Problema de la Cena de Filósofos (cont.)
• Cada filósofo invoca las operaciones takeForks(i)
y returnForks(i) en la siguiente secuencia:
dp.takeForks (i)
COMER
dp.returnForks (i)

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Introducción
• Procesos compiten por recursos y se comunican entre sí
• S.O. proporciona mecanismos de comunicación y
sicronización
• No basta: Conflicto entre necesidades de procesos puede
causar bloqueo indefinido
– Interbloqueo (deadlock)
• Problema conocido y estudiado pero poca repercusión
práctica
• Aparece en otras disciplinas informáticas (p.e. Bases de
datos)
• Múltiples ejemplos de la vida cotidiana
– Carretera de 2 sentidos con puente donde sólo cabe 1 coche
– 2 personas llamándose por teléfono mutuamente

25/03/2022
Introducción
• todos los mecanismos de exclusión mutua
pueden provocar situaciones de bloqueo si
varios threads intentan acaparar recursos de
forma desordenada
• ejemplo típico
thread 1:
synchronized(recurso1) {
// hago mis cosas;
}
}
thread 2:
// hago mis cosas;
}
}

25/03/2022
Descripción del Problema
• Un conjunto de procesos bloqueados, cada
uno tiene un recurso y espera por adquirir
otro recurso sostenido por otro proceso en
el conjunto
• Ejemplo:
– Semáforos A y B, inicializados en 1
P0 P1
wait (A); wait(B)
wait (B); wait(A)

25/03/2022
Ejemplo: Cruzando un Puente
• Tráfico en una sola dirección
• Cada sección del puente puede verse como un
recurso
• Si ocurre un interbloqueo, puede eliminarse si un
carro retrocede (liberar recursos y rollback)
• Varios carros pueden tener que retroceder para
eliminar el interbloqueo
• Susceptible a inanición

25/03/2022
Caracterización de Interbloqueo
• Interbloqueo se caracteriza por la existencia de:
– Cjto. de entidades activas que usan un cjto. de
recursos
• Entidades activas
– Procesos y threads
• Recursos
– Físicos:
• UCPs, memoria, dispositivos. etc.
– Lógicos:
• archivos, semáforos, mutex, cerrojos, mensajes, señales,
etc.

25/03/2022
Caracterización de Interbloqueo
• El interbloqueo puede ocurrir si cuatro
condiciones se dan simultáneamente:
– Exclusión mútua
– Sostener y esperar
– No apropiación
• Recursos son liberados únicamente de manera
voluntaria por quien los tiene, cuando termina su
tarea
– Espera circular

25/03/2022
Tipos de recursos
• Reutilizables o consumibles
– ¿Sigue existiendo después de usarse?
• Uso dedicado o compartido
– ¿Pueden usarlo varios procesos
simultáneamente?
• Con uno o múltiples ejemplares
– ¿Existen múltiples ejemplares del mismo
recurso?
• Expropiables o no expropiables
– ¿Es factible expropiar el recurso cuando se está
usando?

25/03/2022
Recursos reutilizables
• Todos los recursos físicos
• Algunos lógicos (archivos,
cerrojos, mutex, ...)
Primer ejemplo de interbloqueo
Proceso P1 Proceso P2
Solicita(C) Solicita(I)
Solicita(I) Solicita(C)
Uso de rec. Uso de rec.
Libera(I) Libera(C)
Libera(C) Libera(I)
Ejecución sin interbloqueo
P1: solicita(C)
P1: solicita(I)
P2: solicita(I) → bloqueo
P1: libera(I)
P2: solicita(C) → bloqueo
P1: libera(C)
P2: libera(C)
P2: libera(I)
Ejecución con interbloqueo
P1: solicita(C)
P2: solicita(I)
P2: solicita(C) → bloqueo
P1: solicita(I) → interbloqueo

25/03/2022
Recursos consumibles
• Proceso genera recurso y otro lo consume
• Recursos asociados a comunicación y sincronización
– mensajes, señales, semáforos, ...
• Ejemplo: Interbloqueo inevitable (“estructural”)
Proceso P1 Proceso P2 Proceso P3
Enviar(P3) Recibir(P1) Recibir(P2)
Recibir(P3) Enviar(P3) Enviar(P1)
Enviar(P2) Recibir(P1)

25/03/2022
Recursos reutilizables y consumibles
• En general, procesos usan ambos tipos de recursos
– No hay solución general eficiente
• Exposición se centra en recursos reutilizables
• Ejemplo mixto:
Solicita(C) Solicita(C)
Enviar(P2) Recibir(P1)
Libera(C) Libera(C)
Si P2 obtiene C → interbloqueo

25/03/2022
Uso dedicado o compartido
• Recursos compartidos no afectan a
interbloqueos
• Puede haber recursos con ambos tipos de
uso
– En solicitud debe indicarse el modo de uso
deseado
• Si compartido: concedido si no se está usando en m.
exclusivo
• Si exclusivo: concedido si no se está usando
– Por ejemplo, cerrojos sobre archivos
– No tratados en la exposición

25/03/2022
Con uno o múltiples ejemplares
• Modelo general: N unidades de cada recurso
– Solicitud de varias unidades de un recurso
– Ejemplos: sistema con varias impresoras, la memoria, ...
Ejemplo: Memoria disponible: 450KB
Solicita(100K) Solicita(200K)
Solicita(100K) Solicita(100K)
Solicita(100K)
Si P1 satisface 2 primeras y P2 satisface 1ª → interbloqueo

25/03/2022
Expropiables o no expropiables
• Algunas soluciones basadas en expropiación:
– Salvar estado de recurso y asignarlo a otro proceso
– No siempre posible eficientemente: p.ej. plotter
• Ejemplos de recursos expropiables:
– Procesador:
• Cambio de proceso = Expropiación
• Estado de procesador copiado a BCP
– Memoria virtual:
• Reemplazo = Expropiación
• Contenido de página copiado a swap
– Ejemplo de interbloqueo potencial:
• P1 listo (espera UCP) y tiene asignada cinta
• P2 en ejecución (tiene UCP) solicita cinta
• ¿Cómo lo resuelve el S.O.?

25/03/2022
Modelo del sistema
• Conjunto de procesos o threads
• Conjunto de recursos de uso exclusivo (N unidades/recurso)
• Relaciones entre procesos y recursos:
– Asignación: nº unidades asignadas a cada proceso
– Pendientes: nº unid. pedidas pero no asignadas por proceso
• Primitivas genéricas:
– Solicitud (R1[U1],...,Rn[Un])
• U1 unidades del recurso 1, U2 del recurso 2, etc.
• Si todos disponibles, se concederá
• Si no, se bloquea proceso sin reservar ningún recurso
– Liberación (R1[U1],...,Rn[Un])
• Puede causar desbloqueo de otros procesos
• Carácter dinámico del sistema:
– procesos y recursos aparecen y desaparecen

25/03/2022
Grafo de Alocación de Recursos
• Proceso
• Recurso (ejemplo con cuatro instancias)
• Pi solicita instancia de Rj
• Pi sostiene una instancia de Rj
Pi
Pi
Rj
Rj

25/03/2022
Ejemplo de Grafo de Alocación de Recursos

25/03/2022
Ejemplo de Grafo de Alocación de Recursos con
Interbloqueo

25/03/2022
Ejemplo de Grafo de Alocación de Recursos con
un Ciclo pero sin Interbloqueo

25/03/2022
Hechos Puntuales
• Un grafo sin ciclos  no hay interbloqueo
• Un grafo con un ciclo 
– Si sólo hay una instancia de cada recurso,
entonces hay interbloqueo
– Si hay varias instancias de cada recurso,
entonces es posible que haya interbloqueo

25/03/2022
Ejemplo con Java
Thread A Thread B

25/03/2022
Ejemplo con Java (cont.)
Interbloqueo es posible si:
threadA -> lockY -> threadB -> lockX -> threadA

25/03/2022
Representación mediante grafo de
asignación
• Nodos {N}: Procesos {P} + Recursos {R}
– Asociado a cada Ri valor que indica nº de unidades
existentes
• Aristas {A}:
– Asignación (Ri→Pj): Pj tiene asignada 1 unidad de Ri
• Unidades asignadas de Ri  Unidades existentes
– Solicitud (Pi→Rj): Pi tiene pedida y no concedida 1 unid. de
Rj
• Solicitud de recursos de Pi: ¿Todos disponibles?
– Sí: Por cada Rj tantas aristas Rj→Pi como unidades
solicitadas
– No: Por cada Rj tantas Pi→Rj como unidades solicitadas
• Cuando disponibles se cambian a Rj→Pi
• Liberación de recursos de Pi:
– Eliminar aristas Rj→Pi correspondientes

25/03/2022
Ejemplo 1 de representación con grafo
• Ejecución de 3 procesos con 3 recursos R1 (2), R2 (3) y R3 (2)
1. P1: solicita(R1[2]) → solicita 2 unidades
2. P2: solicita(R2[1])
3. P2: solicita(R1[1]) → se bloquea
6. P1: solicita(R2[1], R3[2]) → se bloquea
• Grafo resultante:
N={P1,P2,P3,R1(2),R2(3),R3(2)}
A={R1→P1,R1→P1,R2→P2,P2→R1,R2→P3,
R2→P3,P1→R2,P1→R3,P1→R3}

25/03/2022
Representación gráfica del
ejemplo
P1 P3
1 2
3 4
P2
R1 R2 R3
5
6

25/03/2022
Ejemplo 2 de representación con grafo
(1unid/rec)
1. P1: solicita(R1)
2. P2: solicita(R2)
3. P2: solicita(R1) → bl.
4. P3: solicita(R2) → bl.
5. P4: solicita(R3)
6. P1: solicita(R2)
R2
1
2
3
6
P1 P3
4
P4
P2
R1 R3
5
N={P1,P2,P3,P4,R1(1),R2(1),R3(1)}
A={R1→P1,R2→P2,P2→R1,P3→R2,R3→P4,P1→R2}

25/03/2022
Representación matricial
• Rec. existentes E (dim p): Ei cuántas unid de Ri hay en el sistema
• Asignación A (dim pxr): A[i,j] unid de Rj asignadas a Pi
• Solicitud S (dim pxr):S[i,j] unid de Rj pedidas y no concedidas a Pi
• Rec. disponibles D (dim p): Di cuántas unid de Ri hay disponibles
– Deducible de E y A, su uso facilita descripción de algoritmos
– Sí: Por cada Rj, A[i,j]= A[i,j]+ Uj (unidades solicitadas de Rj)
– No: Por cada Rj, S[i,j]= S[i,j]+ Uj
• Cuando disponibles se resta Uj de S[i,j] y se suma a A[i,j]
– Por cada Rj, A[i,j]= A[i,j]- Uj (unidades solicitadas de Rj)

25/03/2022
Ejemplo 1 de representación matricial
• Ejecución de 3 procesos con 3 recursos R1 (2), R2 (3) y R3
(2)
1.P1: solicita(R1[2]) → solicita 2 unidades
2.P2: solicita(R2[1])
3.P2: solicita(R1[1]) → se bloquea
6.P1: solicita(R2[1], R3[2]) → se bloquea
• Matriz resultante:
2 0 0 0 1 2
A= 0 1 0 S= 1 0 0 E=[2 3 2] D=[0 0 2]
0 2 0 0 0 0

25/03/2022
Ejemplo 2 de representación matricial
(1unid/rec)
• Ejecución de 3 procesos con 3 recursos R1 (2), R2 (3) y R3
(2)
1. P1: solicita(R1)
2. P2: solicita(R2)
3. P2: solicita(R1) → se bloquea
4. P3: solicita(R2) → se bloquea
5. P4: solicita(R3)
6. P1: solicita(R2)
• Matriz resultante:
1 0 0 0 1 0
A= 0 1 0 S= 1 0 0 E=[1 1 1] D=[0 0 0]
0 0 0 0 1 0
0 0 1 0 0 0

25/03/2022
Definición de interbloqueo
• Cjto. de procesos tal que cada uno está esperando un
recurso que sólo puede liberar (generar, si
consumibles) otro proceso del cjto
– No es requisito bloqueo: puede haber espera activa
• Condiciones para interbloqueo (Coffman):
– Exclusión mutua. Recursos de uso exclusivo.
– Retención y espera. Mientras proc. espera por recursos
pedidos, mantiene los ya asignados.
– Sin expropiación. No se expropian recursos asignados.
– Espera circular. Existe lista circular de procesos tal que
cada proceso espera por recurso que tiene siguiente
proceso.
• Son necesarias pero no suficientes:
– Ejemp. 1 y 2 las cumplen pero sólo en el 2º hay
interbloqueo

25/03/2022
Condición necesaria y suficiente
• Idea base: Visión “optimista” del estado actual
– Proceso no bloqueado debería devolver recursos en el
futuro
– Recursos liberados desbloquearían otros procesos
– Esos procesos liberarían recursos desbloqueando a otros,
etc.
• Reducción del sistema por proceso P
– Si se pueden satisfacer necesidades de P con rec.
disponibles
– Nuevo estado hipotético donde P ha liberado todos sus rec.
• Condición necesaria y suficiente:
–  secuencia de reducciones desde estado actual que
incluya a todos los procesos
– Si no: procesos no incluidos están en interbloqueo
• Sistemas con restricciones son más sencillos:
– Si 1 unid/rec → Cond. de Coffman necesarias y suficientes

25/03/2022
Concepto de estado seguro
• “Aunque todos los procesos solicitasen en este momento sus
necesidades máximas, existe un orden secuencial de ejecución
tal que cada proceso pueda obtenerlas”
• Similar al análisis “futuro” de algoritmo de detección
– Pero usando necesidades máx en vez de peticiones actuales
• E. seguro: No interbl. usando como solicitudes necesidades máx.
• Conocimiento a priori no da información sobre uso real
Solicita(C) Solicita(I)
Libera(C) Solicita(C)
Solicita(I) Libera(C)
Libera(I) Libera(I)
Estado inseguro → condición
necesaria pero no suficiente
Ejemplo: no hay interbloqueo y
sí estado inseguro

25/03/2022
Hechos Puntuales
• Si el sistema está en un estado seguro (safe
state)  no hay interbloqueo
• Si el sistema está en un estado inseguro 
interbloqueo es posible
• Evitar interbloqueo 
asegurar que el sistema
nunca entre en un estado
inseguro

25/03/2022
Tratamiento del interbloqueo
• Detección y recuperación. Dejar que se produzca,
detectarlo y recuperarse del mismo.
– Coste de algoritmo + pérdida del trabajo realizado
• Prevención. Asegura que no ocurre fijando reglas para
pedir rec.
– Infrautilización de rec.: se deben pedir antes de necesitarlos
• Predicción. Asegura que no ocurre basándose en
conocimiento de necesidades futuras de los procesos
– Dificultad de conocer futuro
– Coste de algoritmo + Infrautilización de recursos
• Ignorar el problema: Utilizada por la mayoría de los
SS.OO.
– Dada la baja probabilidad de que ocurra y el coste que
conlleva evitarlo (infrautilización y/o coste de algoritmos).

25/03/2022
• Hay 3 técnicas generales para gestionar los interbloqueos
– Temporizaciones de bloqueos
– Prevención de interbloqueos (más adelante…)
– Detección de interbloqueos (más adelante…)
• Conviene detectar interbloqueos cuando se sabe que hay
poca interferencia entre procesos, es decir si...
– Los procesos son cortos y bloquean pocos elementos, o
– La carga de procesos es pequeña
• En otro caso, conviene usar temporizaciones o técnicas de
prevención
Es más difícil prevenir que utilizar temporizaciones o que
detectarlos y romperlos, por lo que en la práctica los
sistemas no suelen emplear las técnicas de prevención
Tratamiento del interbloqueo

25/03/2022
• Un proceso que solicita un bloqueo sólo esperará durante
un período de tiempo predefinido por el sistema
• Si no se concede el bloqueo durante ese tiempo, se
producirá un ‘fin de temporización’: el sistema asumirá que
el proceso está interbloqueado (aunque puede que no), lo
abortará y lo reiniciará automáticamente
Es una solución muy sencilla y práctica
Pero puede hacer que sean abortados y reiniciados procesos
que en realidad no están en un interbloqueo
Temporizaciones de bloqueos

25/03/2022
• Un proceso sufre inanición cuando es seleccionado para
ser abortado (víctima) sucesivamente: nunca termina su
ejecución
– Es similar al bloqueo indefinido
• La solución es asignar prioridades más altas a los procesos
abortados varias veces, para no ser siempre las víctimas
El problema de la inanición

25/03/2022
• El protocolo de control de concurrencia nunca selecciona
a un proceso que está esperando para establecer un
bloqueo, mientras otros procesos continúan ejecutándose
con normalidad
– Ocurre si el esquema de espera da más prioridad a unos procesos
que a otros  esquema de espera injusto
• Dos algoritmos de prevención de bloqueo indefinido
– Consiguen un esquema de espera justo
▪ El primero que llega, es el primero en ser atendido
• Los procesos puede bloquear el elemento X en el orden en que
solicitaron su bloqueo
▪ Aumento de prioridad en la espera
• Cuanto más espera el proceso, mayor es su prioridad
• Cuando un proceso tiene la prioridad más alta de todos, obtiene
el bloqueo y continúa su ejecución
El problema del bloqueo indefinido

25/03/2022
Tratamiento del interbloqueo en los
SS.OO.
• Mayoría lo ignora o no da una solución general
• Distinción entre dos tipos de recursos:
– Recursos internos (propios del S.O.)
• Usados por un proceso en modo sistema
• Uso restringido a ejecución de una llamada
• Ej. semáforo interno para acceder a t. de procesos o buffer
• Interbloqueo puede causar colapso del sistema
– Recursos de usuario
• Usados por un proceso en modo usuario
• Uso durante tiempo impredecible
• Ej. dispositivo dedicado o semáforo de aplicación
• Interbloqueo afecta a procesos y recursos involucrados

25/03/2022
Tratamiento del interbloqueo en los
SS.OO.
• Tratamiento de recursos internos
– Código del S.O. es algo que apenas se modifica
• Se puede estudiar a priori uso de recursos
– Interbloqueo → error de programación de S.O.
– Uso de estrategias de prevención es adecuado
• Dado que tiempo de uso es breve y acotado
• Tratamiento de recursos de usuario
– Código de procesos que usan recursos es impredecible
– No hay tratamiento general para todos los recursos
– Prevención → Infrautilización
– Predicción → Dificultad de conocer información a priori
– Detección y recuperación → Demasiada sobrecarga
• Puede usarse para un único recurso
• P.ej. En 4.4BSD se usa para cerrojos sobre archivos

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
• Verificación periódica del estado del sistema
¿está en un bloqueo mortal?
• Creación de un grafo de espera que muestra las
dependencias entre procesos
– Crear un nodo por cada proceso en ejecución, etiquetado con el
identificador del proceso, P
– Si Pj espera para bloquear el elemento X, ya bloqueado por Pk, crear
una arista dirigida desde Pj a Pk
– Cuando Pk libera el candado sobre X, borrar la arista
correspondiente
• Si existe un ciclo en el grafo de espera, entonces se ha
detectado un interbloqueo entre los procesos
Detección de interbloqueos
Pj Pk
X
Pj Pk

25/03/2022
Detección del interbloqueo
• Aplicación del concepto de reducción
– Esta presentación se limita a alg. para rep. matricial
• Para sistemas con restricciones, algoritmos más sencillos:
– Si 1 unid/rec → Cond. de Coffman necesarias y suficientes
• Espera circular → ciclo en grafo
• Sólo necesario comprobar que no ciclo en grafo O(pr))
R2
1
2
3
6
P1 P3
4
P4
P2
R1 R3
5
Ejemplo 2 tiene interbloqueo

25/03/2022
Recursos con una Sola Instancia
• Usar grafos de espera
– Nodos son procesos
– Pi → Pj si Pi espera por Pj.
• Periódicamente invocar un algoritmo que
busca un ciclo en el grafo
– Si hay un ciclo ➔ interbloqueo
– O(n2) de operaciones, donde n es el # de
vértices en el grafo

25/03/2022
Recursos con una Sola Instancia
Grafos de Asignación de Recursos y de Espera

25/03/2022
Recursos con Múltiples Instancias:
Algoritmo de detección
• Reducción por Pi:
– Si S[i]D (recs. disponibles satisfacen necesidades)
• D= D+A[i](devolver los recursos asignados)
• Algoritmo de complejidad O(p2r):
S=;
Repetir {
Buscar Pi no incluido en S tal que S[i]D;
Si Encontrado {
Reducir por Pi: D = D + A[i]
Añadir Pi a S;
}
} Mientras (Encontrado)
Si (S==P) No hay interbloqueo
Si no: Procesos en P-S están en interbloqueo

25/03/2022
Ejemplo de aplicación del algoritmo (1/3)
• Matriz inicial:
2 0 0 0 1 2
A= 0 1 0 S= 1 0 0 E=[2 3 2] D=[0 0 2]
0 2 0 0 0 0
P1 P3
P2
R1 R2 R3
Primera iteración:
–Estado inicial: S=
–Red. por P3(S[3]D)
D=D+A[3]=[022]
–S={P3}

25/03/2022
• Segunda iteración (D=[022]):
– Red. por P1: S[1]D([012][022])
D=D+A[1]=[022]+[200]=[222]
– S={P3,P1}
P1 P3
P2
R1 R2 R3

25/03/2022
• Tercera iteración (D=[222]):
– Red. por P2: S[2]D([100][222])
D=D+A[2]=[222]+[010]=[232]
– S={P3,P1,P2}
P1 P3
P2
R1 R2 R3

25/03/2022
• Pero... ¿cuándo hay que verificar el estado del sistema
(ejecutar el algoritmo que genera el grafo de espera)?
– A intervalos uniformes de tiempo, o
– A intervalos de tiempo desiguales :
▪ Iniciar algoritmo de detección con un tamaño de intervalo inicial
▪ Cada vez que no se detecta interbloqueo, incrementar el intervalo
– Por ejemplo, al doble del anterior
▪ Cada vez que se detecta interbloqueo, reducir el intervalo
– Por ejemplo a la mitad
▪ Existirán límites superior e inferior del tamaño del intervalo
Activación del algoritmo de detección

25/03/2022
Activación del algoritmo de detección
• ¿Con qué frecuencia se ejecuta?
– Algoritmo tiene coste pero, cuanto antes de
detecte, mejor
• Supervisión continua:
– Por cada petición que no puede satisfacerse
– Puede tener coste demasiado alto
• Supervisión periódica:
– Guiada por tiempo y/o por detección de síntomas
• P.ej. Uso de UCP < umbral con alto grado de
multiprogram.

25/03/2022
Uso de Algoritmo de Detección
• Cuándo y cuán seguido invocarlo?
– Cuán frecuentemente ocurren interbloqueos?
– A cuántos procesos necesitaremos hacerle
rollback?
• Uno para cada ciclo
• Si se invoca arbitrariamente al algoritmo,
puede haber muchos ciclos y no
sabremos qué procesos causaron el ciclo

25/03/2022
Recuperación del interbloqueo
• Una vez detectado, hay que eliminarlo
– Seleccionar sucesivamente procesos implicados y
quitarles sus recursos hasta eliminar interbloqueo
• Alternativas:
– “Retroceder en el tiempo” ejecución de proceso
• Requiere S.O. con mecanismo de puntos de recuperación
– Abortar proceso perdiendo todo su trabajo realizado
• Criterio de selección de procesos basado en:
– prioridad, nº de recursos asignados al proc., t. de
ejecución,...

25/03/2022
• Si el sistema está en un estado de interbloqueo, el SO
necesita abortar algunos procesos...
• ¿Cuáles?  Selección de víctimas
– Es mejor abortar procesos que lleven poco tiempo en ejecución
– Es mejor abortar un proceso que haya hecho pocos cambios
– Es mejor abortar un proceso que todavía debe hacer muchos
cambios
▪ Puede que el SO no conozca esta información
Se trata de abortar los procesos que supongan el mínimo
coste
• Es necesario evitar la inanición
Recuperación del interbloqueo

25/03/2022
Recuperación de Interbloqueos: Terminación de
Procesos
• Abortar todos los procesos bloqueados
• Abortar un proceso a la vez hasta que se
elimine el ciclo
• En qué orden escogeremos a los procesos a
abortar?
– Prioridad de los procesos
– Cuánto tiempo ha estado trabajando, cuánto le
falta para terminar
– Recursos que el proceso ha utilizado
– Recursos que el proceso necesita para completar
– Proceso es batch o interactivo?

25/03/2022
Recuperación de Interbloqueos: Apropiando
Recursos
• Seleccionar una víctima – minimizar costo
• Rollback – retornar a estado seguro, re-
iniciar proceso desde ese estado
• Inanición – al mismo proceso se lo
seleccionará siempre como víctima
– Solución:
• Incluir el # de rollbacks como factor de costo

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Evitando Interbloqueos
Requiere que el sistema tenga cierta información
disponbile a priori
• Modelo más útil y sencillo requiere que cada
proceso declare el # máximo de cada recurso que
puede necesitar
• Algoritmo analiza dinámicamente el estado de la
asignación de recursos para asegurarse que no
es posible entrar en una condición de espera
circular
• El estado de la asignación de recursos se define
por el # de recursos disponibles y asignados, y el
# máximo de pedidos de los procesos

25/03/2022
Algoritmos para Evitar Interbloqueos
• Recursos con una sola instancia
– Usar el gráfico de asignación de recursos
• Recursos con múltiples instancias
– Usar el algoritmo del banquero

25/03/2022
Ejemplo

25/03/2022
Ejemplo en Estado Inseguro

25/03/2022
Algoritmo de predicción
• Esta presentación se limita a alg. para rep. matricial
– Algoritmo del banquero de Dijkstra (1965)
• Requiere nueva estr. de datos: Matriz de necesidad N (dim pxr):
– N[i,j] cuántas unid adicionales de Rj puede necesitar Pi
– Es la diferencia entre necesidades máx. y unidades asignadas
– Refleja tanto solicitudes no concedidas como futuras
• Matriz S queda recogida en N y no la usa el algoritmo
– Inicialmente contiene necesidades máx. de cada proceso
– Sí: Por cada Rj, A[i,j]= A[i,j]+ Uj y N[i,j]= N[i,j]- Uj
– No: Sólo se actualiza S (que no se usa en algoritmo)
• Cuando disponibles, A[i,j]= A[i,j]+ Uj y N[i,j]= N[i,j]- Uj
– Por cada Rj, A[i,j]= A[i,j]- Uj y N[i,j]= N[i,j]+ Uj

25/03/2022
Algoritmo del banquero
• Determina si estado es seguro O(p2r)
S=;
Repetir {
Buscar Pi no incluido en S tal que N[i]D;
Si Encontrado {
Reducir por Pi: D = D + A[i]
Añadir Pi a S;
}
} Mientras (Encontrado)
Si (S==P) El estado es seguro
Si no: El estado no es seguro

25/03/2022
Estrategia de predicción
• Cuando proceso realiza petición de rec. que están disponibles:
– Se calcula nuevo estado provisional transformando A y N
– Se aplica algoritmo del banquero sobre nuevo estado
– Si es seguro, se asignan recursos y nuevo estado se hace
permanente
– Si no, se bloquea al proceso sin asignarle los recursos y se
restaura el estado previo

25/03/2022
Ejemplo de algoritmo del banquero (1/3)
• Estado actual del sistema (es seguro):
1 1 0 3 0 2
A= 0 1 2 N= 2 2 0 D=[2 1 2]
1 0 0 1 1 2
• Secuencia de peticiones:
– P3 solicita 1 unidad de R3
– P2 solicita 1 unidad de R1

25/03/2022
• P3 solicita 1 unidad de R3: Nuevo estado provisional
1 1 0 3 0 2
A= 0 1 2 N= 2 2 0 D=[2 1 1]
1 0 1 1 1 1
• ¿Estado seguro?
1. S=
2. P3: ya que N[3]D →D=D+A[3]=[312] → S={P3}
3. P1: ya que N[1]D → D=D+A[1]=[422]→ S={P3 ,P1}
4. P2: ya que N[2]D→D=D+A[2]=[434]→ S={P3,P1,P2}
Se acepta petición: estado provisional → estado del sistema

25/03/2022
• P2 solicita 1 unidad de R1: Nuevo estado provisional
1 1 0 3 0 2
A= 1 1 2 N= 1 2 0 D=[1 1 1]
1 0 1 1 1 1
• ¿Estado seguro?
1. S=
2. P3: ya que N[3]D →D=D+A[3]=[212] → S={P3}
3. No hay Pi tal que N[i]D → Estado inseguro
No se acepta petición:
Se bloquea al proceso y se restaura estado del sistema

25/03/2022
Limitaciones de estrategias de
predicción
• Conocimiento a priori de necesidades máximas
– Difícil de obtener
– Basado en peor caso posible
• Necesidades máximas no expresan uso real de
recursos
• Infrautilización de recursos
– Niegan uso de recurso aunque esté libre

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Prevención del interbloqueo
• Estrategias basadas en que no se cumpla
una cond. necesaria
• “Exclusión mutua” y “sin expropiación” no
se pueden relajar
– Dependen de carácter intrínseco del recurso
• Las otras dos condiciones son más
prometedoras

25/03/2022
Prevención de Interbloqueos
Asegurar que al menos una de las cuatro
condiciones no se pueda dar.
• Exclusión Mútua – no es requerida para recursos
que se pueden compartir; es necesaria para
recursos no compartibles
• Sostener y Esperar – garantizar que cuando un
proceso solicita un recurso, el proceso no
sostenga ya a otros recursos
– Requiere que el proceso pida y obtenga todos los
recursos que necesita antes de empezar la ejecución,
o permitir que un proceso solicite recursos solamente
cuando no sostiene alguno
– Baja utilización de recursos; inanición es posible

25/03/2022
Prevención de Interbloqueos (cont.)
• No apropiación –
– Si un proceso que sostiene algunos recursos solicita otro recurso
que no puede ser inmediatamente asignado a dicho proceso,
entonces todos los recursos que sostiene el proceso se liberan
– Recursos apropiados se añaden a la lista de recursos por los que
el proceso está esperando
– Proceso se re-iniciará solamente cuando pueda obtener todos los
recursos que necesita (los que ya tenía y los nuevos que está
solicitando)
– OJO: Aplicable a recursos cuyo estado puede ser guardado y
restaurado más tarde (ej.: registros y memoria, no aplicable a
impresoras, cintas, etc.)
• Espera circular – imponer un ordenamiento total en los recursos, y
hacer que cada proceso solicite los recursos en orden ascendente
con respecto a ese ordenamiento

25/03/2022
Prevención basada en evitar “sostener(retener) y
esperar”
• Sólo pueden solicitarse recursos si
no se tiene ninguno asignado
– Infrautilización
t1: solicita(A,B,C)
(t1,t2): sólo utiliza A
(t2,t3): utiliza A y B
t3: Libera(A)
(t3,t4): sólo utiliza B
(t4,t5): utiliza B y C
t5: Libera(B)
(t5,t6): sólo utiliza C
t6: Libera(C)
t7: solicita(D)
(t7,t8): sólo utiliza D
t8: Libera(D)
A
tiempo B C D
t1
RECURS
OS
t5
t4
t3
t8
t7
t6
t2

25/03/2022
Prevención basada en evitar “espera
circular”
• Método de las peticiones ordenadas:
– Se establece un orden total de los recursos del sistema
– Restricción: Proceso sólo puede pedir recursos en orden
– Conlleva infrautilización
• En ejemplo anterior:
– Si A<B<C<D → Proceso pide justo cuando necesita
– Si A>B>C>D → Proceso pide todo en t1
• Se deben ordenar recursos según orden más frecuente de uso

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
Comandos para administración de
procesos
• La más simple definición de un proceso podría ser
que es una instancia de un programa en ejecución
(corriendo).
– A los procesos frecuentemente se les refiere como
tareas.
– El contexto de un programa que esta en ejecución es
lo que se llama un proceso.
– Este contexto puede ser mas procesos hijos que se
hayan generado del principal (proceso padre), los
recursos del sistema que este consumiendo, sus
atributos de seguridad (tales como su propietario y
permisos de archivos asi como roles y demás de
SELinux), etc.

25/03/2022
procesos
• Linux, como se sabe, es un sistema operativo
multitarea y multiusuario. Esto quiere decir que
múltiples procesos pueden operar simultáneamente
sin interferirse unos con los otros.
• Cada proceso tiene la "ilusión" que es el único
proceso en el sistema y que tiene acceso exclusivo a
todos los servicios del sistema operativo.
• Programas y procesos son entidades distintas. En un
sistema operativo multitarea, múltiples instancias de
un programa pueden ejecutarse sumultáneamente.
• Cada instancia es un proceso separado. Por ejemplo,
si cinco usuarios desde equipos diferentes, ejecutan el
mismo programa al mismo tiempo, habría cinco
instancias del mismo programa, es decir, cinco
procesos distintos.

25/03/2022
procesos
• Cada proceso que se inicia es referenciado con
un número de identificación único conocido como
Process ID PID, que es siempre un entero
positivo.
• Prácticamente todo lo que se está ejecutando en
el sistema en cualquier momento es un proceso,
incluyendo el shell, el ambiente gráfico que puede
tener múltiples procesos, etc.
• La excepción a lo anterior es el kernel en si, el
cual es un conjunto de rutinas que residen en
memoria y a los cuales los procesos a través de
llamadas al sistema pueden tener acceso.

25/03/2022
ps
• El comando ps es el que permite informar sobre el estado de
los procesos. ps esta basado en el sistema de archivos /proc,
es decir, lee directamente la información de los archivos que
se encuentran en este directorio.
• Tiene una gran cantidad de opciones, incluso estas opciones
varían dependiendo del estilo en que se use el comando.
Estas variaciones sobre el uso de ps son las siguientes:
– Estilo UNIX, donde las opciones van precedidas por un guión -
– Estilo BSD, donde las opciones no llevan guión
– Estilo GNU, donde se utilizan nombres de opciones largas y van
precedidas por doble guión --
• Sea cual sea el estilo utilizado, dependiendo de las opciones
indicadas, varias columnas se mostrarán en el listado de
procesos que resulte, estas columnas pueden ser entre
muchas otras, las siguientes (y principales):
1

25/03/2022
Columna Descripción
p o PID Process ID, número único o de identificación del proceso.
P o PPID Parent Process ID, padre del proceso
U o UID User ID, usuario propietario del proceso
t o TT o TTYTerminal asociada al proceso, si no hay terminal aparece entonces un '?'
T o TIME Tiempo de uso de cpu acumulado por el proceso
c o CMD El nombre del programa o camndo que inició el proceso
RSS Resident Sise, tamaño de la parte residente en memoria en kilobytes
SZ o SIZE Tamaño virtual de la imagen del proceso
NI
Nice, valor nice (prioridad) del proceso, un número positivo significa menos
tiempo de procesador y negativo más tiempo (-19 a 19)
C o PCPU Porcentaje de cpu utilizado por el proceso
STIME Starting Time, hora de inicio del proceso
S o STAT •Status del proceso, estos pueden ser los siguientes
R runnable, en ejecución, corriendo o ejecutándose
•S sleeping, proceso en ejecución pero sin actividad por el momento, o esperando
por algún evento para continuar
•T sTopped, proceso detenido totalmente, pero puede ser reiniciado
•Z zombie, difunto, proceso que por alguna razón no terminó de manera correcta,
no debe haber procesos zombies
•D uninterruptible sleep, son procesos generalmente asociados a acciones de IO
del sistema
•X dead, muerto, proceso terminado pero que sigue apareciendo, igual que los Z
no deberían verse nunca

25/03/2022
ps
• A continuación algunos cuantos ejemplos de ps con la
salida recortada…
1

25/03/2022
ps
1

25/03/2022
pstree
• Muestra los procesos
en forma de árbol,
pstree --help te da
las opciones más
comunes.
• Recomiendo uses lo
uses con la opción -A y
-G para que te un árbol
con líneas con líneas
estilo ASCII y de
terminal VT100
respectivamente,
puedes añadir también
-u para mostrar entre
paréntesis al usuario
propietario del proceso:
2

25/03/2022
kill
• El comando kill, que literalmente quiere decir
matar, sirve no solo para matar o terminar
procesos sino principalmente para enviar señales
(signals) a los procesos.
• La señal por default (cuando no se indica ninguna
es terminar o matar el proceso), y la sintaxis es kill
PID, siendo PID el número de ID del proceso.
• Asi por ejemplo, es posible enviar una señal de
STOP al proceso y se detendrá su ejecución,
después cuando se quiera mandar una señal de
CONTinuar y el proceso continuara desde donde
se quedo.
3

25/03/2022
kill
3

25/03/2022
kill
• La lista previa presenta una lista de todas las posibles
señales que pueden mandarse a un proceso y estas
pueden ser invocadas a través del número de la señal
o de su código, por ejemplo:
• Las señales más comunes son la 19 y 20 que
detienen momentáneamente la ejecución de un
proceso o programa, 18 la continua, 1 que es la señal
de hang up que obliga al proceso a releer sus
archivos de configuración estando en ejecución y 9
que termina rotundamente un proceso.
3

25/03/2022
killall
• El comando killall, que funciona de manera similar a
kill, pero con la diferencia de en vez de indicar un PID se
indica el nombre del programa, lo que afectará a todos los
procesos que tengan ese nombre.
• Asi por ejemplo si se tienen varias instancias ejecutándose
del proxy server squid, con killall squid eliminará todos
los procesos que se esten ejecutando con el nombre 'squid'
4
#> killall -l (lista de posibles señales)
#> killall -HUP httpd (manda una señal de "colgar", detenerse releer sus archivos de configuración y reiniciar)
#> killall -KILL -i squid (manda señal de matar a todos los procesos squid pero pide confirmación en cada uno)

25/03/2022
nice
• Permite cambiar la prioridad de un proceso. Por defecto,
todos los procesos tienen una prioridad igual ante el CPU que
es de 0.
• Con nice es posible iniciar un programa (proceso) con la
prioridad modificada, más alta o más baja según se requiera.
Las prioridades van de -20 (la más alta) a 19 la más baja.
• Solo root o el superusuario puede establecer prioridades
negativas que son más altas. Con la opción -l de ps es
posible observar la columna NI que muestra este valor.
5

25/03/2022
renice
• Asi como nice establece la prioridad de un
proceso cuando se incia su ejecución, renice
permite alterarla en tiempo real, sin necesidad de
detener el proceso.
6
al)

25/03/2022
nohup y &
• Cuando se trata ejecutar procesos en background (segundo
plano) se utiliza el comando nohup o el operador & . Aunque
realizan una función similar, no son lo mismo.
• Si se desea liberar la terminal de un programa que se espera
durará un tiempo considerable ejecutándose, entonces se
usa .
– Esto funciona mejor cuando el resultado del proceso no es
necesario mandarlo a la salida estándar (stdin), como por
ejemplo cuando se ejecuta un respaldo o se abre un programa
Xwindow desde la consola o terminal.
– Para lograr esto basta con escribir el comando en cuestión y
agregar al final el símbolo & (ampersand).
7

25/03/2022
nohup y &
• Sin embargo lo anterior produce que el padre del proceso
PPID que se invocó sea el proceso de la terminal en si, por lo
que si cerramos la terminal o salimos de la sesión también se
terminaran los procesos hijos que dependan de la terminal,
no muy conveniente si se desea que el proceso continué en
ejecución.
• Para solucionar lo anterior, entonces se usa el comando
nohup que permite al igual que '&' mandar el proceso y
background y que este quede inmune a los hangups (de ahí
su nombre nohup) que es cuando se cuelga o termina la
terminal o consola de la cual se ejecutó el proceso.
7
Así se evita que el
proceso se "cuelgue" al
cerrar la consola.

25/03/2022
jobs
• Si por ejemplo, se tiene acceso a una única consola o
terminal, y se tienen que ejecutar varios comandos que se
ejecutarán por largo tiempo, se pueden entonces como ya se
vió previamente con nohup y el operador '&' mandarlos a
segundo plano o background con el objeto de liberar la
terminal y continuar trabajando.
• Pero si solo se está en una terminal esto puede ser difícil de
controlar, y para eso tenemos el comando jobs que lista los
procesos actuales en ejecución:
8

25/03/2022
jobs
• En el ejemplo previo, se ejecutó el comando yes y se envió a
background (&) y el sistema devolvió [1] 26837, indicando asi que
se trata del trabajo o de la tarea [1] y su PID, lo mismo con la
segunda tarea que es un listado recursivo desde la raíz y enviado a
un archivo, esta es la segunda tarea.
• Con los comandos fg (foreground) y bg background es posible
manipular procesos que esten suspendidos temporalmente, ya sea
porque se les envió una señal de suspensión como STOP (20) o
porque al estarlos ejecutando se presionó ctrl-Z. Entonces para
reanudar su ejecución en primer plano usaríamos fg:
8
Obsérvese como al traer en primer
plano al 'job' o proceso 1, este
adquirió el símbolo [+] que indica
que esta al frente. Lo mismo sería
con bg que volvería a reinicar el
proceso pero en segundo plano. Y
también es posible matar los
procesos con kill indicando el
número que devuelve jobs: kill %1,
terminaría con el proceso
en jobs número 1.

25/03/2022
top
• Una utilería muy usada y muy útil para el monitoreo en
tiempo real del estado de los procesos y de otras
variantes del sistema es el programa llamado top, se
ejecuta desde la línea de comandos, es interactivo y
por defecto se actualiza cada 3 segundos.
9

25/03/2022
top
• Estando adentro de la aplicación,
presionando 'h' muestra una ayuda de los
posibles comandos que permiten configurar
top, por ejemplo, al presionar 's' pregunta por
el tiempo en segundos de actualización, etc.
• Estas son algunas de las herramientas, las
más importantes y usadas, para administrar
procesos, hay varios programas en
ambientes gráficos que en una sola pantalla
permiten todo lo anterior y más, y en línea de
comandos te recomiendo htop, que es como
un top pero en esteroides.
9

25/03/2022
Contenido
Concurrencia:
Escritores,
Consumidor,
Comensales.
• Interbloqueo
un interbloqueo
– Comandos para

25/03/2022
En Linux existen muchas librerías que implementan los threads ya que, la diferencia
de los procesos (fork), es que forman parte del kernel del sistema.
Probablemente la librería de threads más utilizada es la librería pthread que es la que
vamos a estudiar.
Para utilizar la librería pthread és necesario incluir el archivo pthread.h (#include
<pthread.h>) y cuando se compile el programa linkearlo con la librería (-lpthread).
Las funciónes de manejo de threads son las siguientes:
Creación de un Thread
int pthread_create (pthread_t *thread, pthread_attr_t *attr,
void* (*start_routine)(void *), void * arg);
Esta función crea un nuevo thread de ejecución que llevará la cabo la función
start_routine al mismo tiempo que el thread principal.
La función start_routine debe tener el siguinte prototipo:
void * start_routine (void *param);
El parámetro arg és la información que se le pasará como parámetro á la función
start_routine. Si la rutina en el precisa de ningún argumento, se pondra en NULL.
El parámetro thread és la dirección de memoria de una variable de tipo pthread_t
donde se almacenará la información del nuevo thread creado.
El parámetro attr contiéne los atributos que va la tener el nuevo thread (ver las
funciones de manejo de atributos). Si queremos los atributos por defecto,
pondremos NULL

25/03/2022
Threads Bajo Linux
Hacer que el thread principal espere a que terminen los threads en ejecución:
int pthread_join (pthread_t th, void **pthread_return);
La función pthread_join hace que la función que lo llama ( el thread principal)
espere la la finalización de los threads secundarios antes de rematar, de forma
que pueda liberar sus recursos.
El parámetro th és el thread por el que se va a esperar que finalice.
El parámetro pthread_return almacenará el valor devuelto por el thread finalizado.
Finalizar la ejecución del thread actual
void pthread_exit (void *retval);
Esta función provoca la finalización del thread en ejecución devolviendo el valor
retval. Es el equivalente la escribir return retval.
'Independizar' la ejecución del hilo del que lo creo (garantizar que el hilo libere sus
recursos al finalizar)
int pthread_detach (pthread_t th);
Esta función hace que el thread th se ejecute en forma independiente del thread
principal, es decir, que una vez finalizado, liberará sus recursos por si mismo. Thread
detached con esta función en el se le podrá hacer un pthread_join para esperar por
su finalización.

25/03/2022
Threads Bajo Linux
Manejo de los atributos del thread que se va la crear
int pthread_attr_init (pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate);
int pthread_attr_getdetachstate(pthread_attr_t *attr, int *detachstate);
int pthread_attr_setschedpolicy(pthread_attr_t *attr, int schedpolicy);
int pthread_attr_getschedpolicy(pthread_attr_t *attr, int *schedpolicy);
int pthread_attr_setschedparam(pthread_attr_t *attr, int schedparam);
int pthread_attr_getschedparam(pthread_attr_t *attr, int *schedparam);
int pthread_attr_setinheritsched(pthread_attr_t *attr, int inheritsched);
int pthread_attr_getinheritsched(pthread_attr_t *attr, int *inheritsched);
int pthread_attr_setscope(pthread_attr_t *attr, int scope);
int pthread_attr_getscope(pthread_attr_t *attr, int *scope);
Para poner los atributos la un thread, se debe pedir primero una estructura de tipo
pthread_attr_t y luego pasarla como argumento la la función pthread_create, si la
esta función le pasamos NULL como atributo el thread tomara los atributos por
defecto.

25/03/2022
La función pthread_attr_init inicializa el parámetro attr con los atributos por defecto del
threads, mentras que pthread_attr_destroy elimina los atributos que se crearon .
Para manipular los distintos atributos que tienen los threads se utilízan el resto de
las funciónes, siendo las funciónes que comienzan por pthread_attr_set para poner
atributos y las que comienzan porpthread_attr_get para saber que atributos tiene.
Los atributos que se pueden manipular son:
detachstate : controla si el thread se crea en un estado en el que se puede hacer un
pthread_join (PTHREAD_CREATE_JOINABLE) o en un estado desenganchado
(como si le hicieramos un pthread_detach) (PTHREAD_CREATE_DETACHED).
El valor por defecto es PTHREAD_CREATE_JOINABLE.
schedpolicy: controla la política de planificación del proceso (sheduling) vinculados al
thread creado. Puede ser SCHED_OTHER (planificación normal), SCHED_RR
(round robin) el SCHED_FIFO (planificación FIFO, también llamada FCFS (First
Comed First Served)). El valor por defecto es SCHED_OTHER.
schedparam: contiene los parámetros de la política de planificación de procesos
empleada en el thread, normalmente su prioridad de ejecución. Por defecto la
prioridad es 0 y unicamente tiene sentido con las políticas SCHED_FIFO y
SCHED_RR.
inheritsched: Indica si las políticas de planificación y sus parámetros se collen del
proceso que lanza el thread (PTHREAD_INHERIT_SCHED) o de los atributos
indicados (schedpolicy y schedparam) en el momento de crear el thread.
(PTHREAD_EXPLICIT_SCHED). Por defecto es PTHREAD_EXPLICIT_SCHED.
scope: el único valor soportado en Linux es PTHREAD_SCOPE_SYSTEM que indica
que los threads competirán con el resto de los procesos del sistema para utilizar la
CPU. El otro valor especificado estándar pero no soportado en Linux es
PTHREAD_SCOPE_PROCESS que indica que los threads únicamente compiten
con el resto de los threads del proceso en funcionamento.

25/03/2022
Supongamos que temos un programa que lanza hilos de ejecución para atender
conexiónes para vender entradas para un espectáculo y que inicialmente tenemos
100 entradas. de esta forma podremos atender los clientes de dos en dos.
Para vender las entradas cada hilo comprueba si quedan entradas (inicialmente
tenemos 100). Si quedan, realiza la venta restándole 1 al número de entradas que
quedan por vender.
A primera vista este algoritmo es correcto, pero supongamos que queda 1 entrada
por vender y la solicitan dos clientes al mismo tiempo. Cada thread atenderá un
cliente; en primero lugar comprobarán si quedan entradas, viendo ambos threads
que queda una entrada y procedendo a efectuar la venta. ¡ Como resultado se
venderá una entrada de más !.
Este tipo de situaciones recibe el nome de condición de competencia o
condicion de carrera (racing condition), ya que varios procesos compiten por un
recurso. Para solucionlo los threads proporcionan Mutex, Semáforos y Condición
de Sincronización.
Mutex, Semáforos y Condición
de Sincronización en linux

25/03/2022
Los mutex permiten bloquear una parte del código, de forma que ningún otro
hilo de ejecución pueda accederla mientras no se libere el bloqueo. de esta
forma , si los threads bloquean el código que comprueba el número de
entradas que quedan y lo liberan después de realizada la venta, obligamos a
que primero se ejecute la parte crítica un proceso y luego la otra.
Las funcións de manejo de mutex son las siguientes:
pthread_mutex_t fastmutex= PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t recmutex=PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_mutex_t errchkmutex =
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t
*mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
Mutex

25/03/2022
Un mutex es un dispositivo de exclusión mutua útil para proteger estructuras de
datos compartidas de modificaciónes concurrentes, y para implementar secciones
críticas y monitores.
Los mutex tienen dos estados posibles: unlocked (libre, no ocupado por ningún
thread) o locked (ocupado por un thread). Un mutex nunca puede estar ocupado
por más de un thread.
Si un thread intenta ocupar un mutex ya ocupado, quedará a la espera de que el
thread que tienen el mutex lo libere.
La función pthread_mutex_init inicializa el objeto mutex indicado por el parámetro
mutex de acuerdo con los atributos indicados en el parametro mutexattr. Si el
parámetro mutexattr es NULL, se utilizarán los atributos por defecto.
La implementación de Linux de los Threads (pthreads) únicamente soporta un
atributo para los mutex: el tipo (Mutex Kind).
Los mutex pueden ser "fast", "recursive" o "error checking" , indicando cando el
mutex puede ser vuelto a ocupar por un thread que lo tiene ya ocupado (recursive).
el tipo error checking verifica que el thread que quita el bloqueo sea el mismo que
el que lo puso; en los otros tipos un thread puede quitar el bloqueo puesto por un
thread distinto. Por defecto el tipo es "fast".

25/03/2022
Las variables de tipo pthread_mutex_t pueden ser inicializadas también de forma
estática mediante las constantes PTHREAD_MUTEX_INITIALIZER (fast mutex),
PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP (recursive mutex) y
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP (error checking mutex).
La función pthread_mutex_lock ocupa el mutex indicado como parámetro. Si el
mutex no está ocupado por otro thread, lo ocupa y continúa la ejecución, si el
mutex ya el tienen ocupado otro thread, suspende la ejecución del thread hasta
que esté disponible.
Si el mutex ya está ocupado por el thread que intenta hacer un nuevo
pthread_mutex_lock, el comportamento depende del tipo de mutex. Si es fast, el
thread queda a la espera de que el mutex sea liberado, lo que producirá un dead
lock (bloqueo mortal); si es error checking la función devolverá el código de error
EDEADLK y si es recursive, el thread reocupa el mutex devolviendo el número de
veces que lo tiene ocupado; para liberar el mutex será necesario hacer el mismo
número de llamadas a pthread_mutex_unlock las veces que se tenga ocupado.
pthread_mutex_trylock es igual que pthread_mutex_lock, pero no bloquea el
thread si el mutex está ocupado por outro, si no que devuelve el código de error
EBUSY.

25/03/2022
pthread_mutex_unlock "libera" el mutex ocupado por el thread. Si el mutex es fast
, siempre se liberará pero si es recursive decrementará la cuenta de ocupación del
mutex, liberándolo si es 0. en el tipo error_check se verifica que el mutex pertence
realmente el thread que intenta liberalo, y si no es así devuelve un código de error,
los otros tipos permiten liberar mutex que no les pertencen, siendo esta una
característica no portable y que no se debe utilizar (en realidad es un bug).
pthread_mutex_destroy destruye un objeto mutex liberando todos los recursos
que tenga ocupados. Únicamente se podrán destruir mutex que no esten ocupados
por ningún thread. (Como en Linux los mutex no ocupan recursos, esta función en
realidad no hace nada).
int pthread_mutexattr_init (pthread_mutexattr_t *attr);
int pthread_mutexattr_destroy (pthread_mutexattr_t *attr);
int pthread_mutexattr_settype (pthread_mutexattr_t *attr,int kind);
int pthread_mutexattr_gettype (const pthread_mutexattr_t *attr, int *kind);
pthread_mutexattr_init inicializa el objeto mutex attr y inicializa con valores por
defecto.
pthread_mutexattr_destroy destruye un objeto que tiene atributos de un mutex. En
Linux esta función no tienen ningún efecto.
pthread_mutexattr_settype y pthread_mutexattr_gettype sirven para poner y para
obtener el tipo de mutex. Los atributos pueden ser PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_RECURSIVE_NP o PTHREAD_MUTEX_ERRORCHECK_NP.

25/03/2022
Otro mecanismo que pueden utilizar los threads para proteger secciónes de
código son los semáforos.
Un semáforo es similar a un mutex con un contador.
Las operaciónes principales son:
espera a que el cuentador sea distinto de 0 y le resta 1 al contador antes de
continuar sumar 1 al contador
Si el contador es 0 indicará que el thread no puede acceder a la sección
crítica, y
si es >0, podrán acceder tantos threads como valor tenga el contador.
Las funciónes de manejo de semáforos son:
# include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
int sem_wait(sem_t *sem);
int sem_trywait(sem_t *sem);
int sem_post(sem_t *sem);
int sem_getvalue(sem_t *sem,int *sval);
int sem_destroy(sem_t *sem);
Semáforos

25/03/2022
sem_init inicializa el semáforo sem, poniendo su cuenta inicial en value. el
argumento pshared indica cando el semáforo es local al proceso actual (0)
o compartido entre varios procesos (distinto de 0). Linux únicamente
soporta semáforos locales al proceso actual (pshared debe ser igual a 0).
sem_wait suspende la ejecución del thread mentras la cuenta del
semáforo sea 0. Cuando la cuenta deje de ser 0, le resta 1 y continuará la
execución.
sem_trywait es similar a sem_wait pero en lugar de suspender la
ejecución devolverá el error EAGAIN
sem_post incrementará la cuenta del semáforo que se le indique.
sem_getvalue devolverá la cuenta del semáforo sem en sval.
sem_destroy elimina el semáforo que se le indique.

25/03/2022
Condicion de Sincronización
Una Condición de Sincronización permite suspender la ejecución de un thread
mientras algúnos datos compartidos entre varios threads no cumplan un requisito.
Las operacións básicas de las condicíóns de sincronización son:
Señalizar una Condición (indicar que el requisito se cumple), y
Esperar por la Condición (esperar que otro thread señalice la condición ).
Una condición de sincronización siempre está asociada con un mutex para evitar
la condición de competencia que se produce si un thread va a esperar por una
condición justo al mismo tempo que otro thread la señaliza, sin darle tiempo de
esperar por ella.
Las funcións de manejo de condicion de sincronización son las siguientes:
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
const struct timespec *abstime);
int pthread_cond_destroy(pthread_cond_t *cond);
pthread_cond_init inicializa la variable de condición cond usando los atributos
especificados en el parámetro cond_attr, o los atributos por defecto si el parámetro
es NULL.

25/03/2022
La implementación en Linux de los threads no soporta atributos para las condiciones,
de forma que cond_attr es siempre ignorado. las variables de tipo pthread_cond_t
también pueden ser inicializadas estáticamente mediante la constante
PTHREAD_COND_INITIALIZER.
pthread_cond_signal hace que continúe uno de los threads que están a la espera
de la variable que se le pasa como parámetro, pero no se sabe cual (puede ser
cualquera de los que están en espera para esa condición).
pthread_cond_broadcast hace que continúen todos los threads que estan la
esperar por la condición especificada como parámetro.
pthread_cond_wait desbloquea el mutex y suspende el thread a la espera de que
se cumpla la condición indicada (cond). Antes de llamar a esta función es necesario
bloquear el mutex llamando á la función pthread_mutex_lock. Antes de volver, esta
función vuelve a bloquear el mutex de forma automática. Para evitar la
condición de competencia ya comentada, el thread que señalice la condición con
pthread_cond_signal debe bloquear el mutex antes.
pthread_cond_timedwait trabaja del la mismo forma que pthread_cond_wait, pero
su condición no se cumple en el tiempo indicado en el parámetro abstime, la
función devuelve el error ETIMEDOUT. El tempo viene expresado en el formato de
la función time (número de segundos dende el 1 de enero de 1970).
pthread_cond_destroy libera una variable de condición y todos los recursos que
pueda tener asociados. En la implementación de Linux no tienen ningún efecto.
Tanto la función pthread_cond_wait como pthread_cond_timedwait son 'puntos de
cancelación'.

25/03/2022
Un caso práctico
Consideremos dos variables compartidas x e y protegidas por el mutex mut y la
condición cond que será señalizada cuando x sea mayor que y:
int x,y;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Los threads que esperan, incluirán el siguiente código:
// Bloqueo de la sección crítica
pthread_mutex_lock (&mut);
// En realidad bastaría un if, pero si hay varios threads...
while(x<=y) {
// Esperamos la señal..
pthread_cond_wait(&cond,&mut);
}
/* Aquí trabajaríamos con '''x''' y con '''y''' */
// los otros threads pueden continuar...
pthread_mutex_unlock(&mut);

25/03/2022
El thread que señaliza la condición tendría el código siguiente:
críticapthread_mutex_lock(&mut); // Bloqueo de la sección
/* Aquí trabajaríamos con '''x''' y con '''y''' */
// Señalo la condición. Si únicamente tuviera 1 thread en espera bastaría
// pthread_cond_signal
if (x>y) pthread_cond_broadcast(&cond);
pthread_mutex_unlock(&mut); // Libero el mutex
//Si quisieramos que la espera tuviera un timeout de 5 segundos:
struct timeval now;
struct timespec timeout;
int retcode;
pthread_mutex_lock(&mut);
gettimeofday(&now);
timeout.tv_sec=now.tv_sec+5;
timeout.tv_nsec=now.tv_usec*1000;
retcode=0;
while ((x<=y) && (retcode != ETIMEDOUT)) {
retcode=pthread_cond_timedwait(&cond,&mut,&timeout);
}
if (retcode == ETIMEDOUT) { /*Error,se acabo el tiempo (pasaron los 5 segundos) */}
else { /* Trabajar con las variables '''x''' e '''y''' */ }
pthread_mutex_unlock(&mut);

25/03/2022
Cancelación de Threads
La cancelación es un mecanismo por el que un thread puede provocar la
finalización de otro enviándole una petición de finalización. Dependendo de la
forma de trabajar del otro thread, puede ignorar la petición, finalizar
inmediatamente o esperar alcanzar un punto de cancelación. Si el thread atiende
inmediatamente la petición termina devolviendo el código PTHREAD_CANCELED.
Los puntos de cancelación son puntos de ejecución donde se comprueba si hay
peticiónes de cancelación pendientes. Las siguientes funcións tienen puntos de
cancelación: pthread_join, pthread_cond_wait, pthread_cond_timedwait
pthread_testcancel, sem_wait, sigwait.
Las funcions de cancelación de thread son las siguientes:
int pthread_cancel(pthread_t thread);
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type,int *oldtype);
int pthread_testcancel(void);

25/03/2022
• pthread_cancel envía una petición de cancelación al thread indicado como
argumento.
• pthread_setcancelstate cambia el estado de cancelación del thread, es decir
indica cuando se ignorarán las señales de cancelación y cando no. El
parámetro state puede ser PTHREAD_CANCEL_ENABLE para permitir la
cancelación o PTHREAD_CANCEL_DISABLE para no permitirla. Si el
parámetro oldstate no es NULL, devolverá el estado de cancelación previo.
• pthread_setcanceltype cambia el tipo de respusta a las peticións de
cancelación, y puede ser PTHREAD_CANCEL_ASYNCHRONOUS (para
cancelación inmediata) o PTHREAD_CANCEL_DEFERRED (esperar al
siguiente punto de cancelación). Si el parámetro oldtype no es NULL
almacenará el tipo de cancelación anterior.
• pthread_testcancel únicamente sitúa un punto de cancelación en el lugar en
que se llame.
• Los threads se créan por defecto con la cancelación activa con el tipo
PTHREAD_CANCEL_DEFERRED

25/03/2022
Envío y Gestión de Señales
int pthread_sigmask(int how, const sigset_t *newmask, sigset_t *oldmask);
int pthread_kill(pthread_t thread, int signo);
int sigwait(const sigset_t *set, int *sig);
thread_sigmask cambia el conjunto de señales que va a respostar el thread.
Si el parámetro oldmask no es NULL, almacenará el conjunto viejo de señales.
Si how es SIG_SETMASK el conjunto de señales inicializa la newmask, si es
SIG_BLOCK engádense las señales especificadas en newmask y si es
SIG_UNBLOCK se quítan las señales especificadas en newmask del conjunto
de señales los que va a respostar el thread. Los conjuntos de señales se
manipulan con las funciónes:
int sigemptyset(sigset_t *conjunto);//vacía el conjunto de señales indicado
int sigfillset(sigset_t *conjunto);//incluye todos los señales existentes en el
conjunto indicado.
int sigaddset(sigset_t *conjunto, int numseñal);//engade el señal indicado en el
conjunto).
int sigdelset(sigset_t *conjunto, int numseñal); (elimina la señal indicad del
conjunto).
int sigismember(const sigset_t *conjunto, int numseñal); (indica si el señal
indicado pertence el conjunto).
pthread_kill envía la señal signo al thread especificado. sigwait suspende el thread
hasta que recibe una señal del conjunto indicado en set, almacenando entonces la
señal recibida en sig. Se ignorará cualqueir función asociada a la señal.

25/03/2022
Mecanismos de
comunicación y
sincronización de procesos
Unidad 2
Final de la unidad

SO Unidad 2: Mecanismos de comunicación y sincronización de procesos

Más contenido relacionado

La actualidad más candente (20)

Similar a SO Unidad 2: Mecanismos de comunicación y sincronización de procesos (20)

Más de Franklin Parrales Bravo (20)

Último (12)

SO Unidad 2: Mecanismos de comunicación y sincronización de procesos