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.

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

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

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

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

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

Más de Franklin Parrales Bravo

Más de Franklin Parrales Bravo (20)

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