El documento describe el problema clásico de sincronización conocido como "el barbero dormilón". Explica que involucra la interacción de procesos de un barbero y clientes que esperan turno en la peluquería. Detalla soluciones al problema usando semáforos y objetos de exclusión mutua para proteger la sección crítica. También incluye codificaciones del problema en Java y C++ para ilustrar su implementación.

1. PROBLEMAS CLÁSICOS DE COMUNICACIÓN DE
PROCESOS “EL BARBERO DORMILÓN”
“Palma Steven”, “Ramírez Inés”, “Rocafuerte Andrea”, “Torres Joselyn”, “Vera Jonathan”
Facultad de Sistemas y Telecomunicaciones
Carrera de Electrónica y Telecomunicaciones
Universidad Estatal Península de Santa Elena
La Libertad – Ecuador
“steven_palma2013@hotmail.com”, “inesol1@hotmail.com”, “andrearg2212@hotmail.com”,
“joselyntorresgonzalez@hotmail.com”, “jonathan_51194@hotmail.com”
dquirumbay@upse.edu.ec
SISTEMAS OPERATIVOS
Resumen
El propósito de esta aplicación, es el de mostrar el funcionamiento de un
algoritmo de administración de procesos, los cuales se adentran en los
problemas clásicos del barbero dormilón, aquí se dará a conocer las
variedades de la ejecución de este proceso.

2. I. INTRODUCCIÓN
Prácticamente esta teoría está
basada en lo que es la vida real
porque es un problema de
sincronización, hace esta
comparación por lo que
encontramos siempre tipos de
procesos de los cuales hay que
esperar que se termine uno para
que empiece a procesar otro o más
bien que se encargue cada uno de
que estén ordenados y esperando
un determinado tiempo para
avanzar.
II. DESARROLLO
 El barbero dormilón
El problema consiste en una
barbería en la que trabaja, un
barbero tiene un único sillón de
barbero y varias sillas para esperar.
Cuando no hay clientes, el barbero
se sienta en una silla y se duerme,
cuando llega un nuevo cliente, éste
o bien despierta al barbero o si el
barbero esta afeitado a otro cliente
se sienta en una silla o se va si
todas las sillas están ocupadas por
clientes esperando. El problema
consiste en realizar la actividad del
barbero sin que ocurran condiciones
de carrera. La solución implica el
uso de semáforos y objetos de
exclusión mutua para proteger la
sección crítica.
Un semáforo es una variable
protegida que constituye el método
clásico para restringir o permitir el
acceso a recursos compartidos
como por el ejemplo un recurso de
almacenamiento, en un entorno de
multiprocesamiento, esto fue
inventado por Edsger Dijkstra en
1971 y se usó por primera vez en el
sistema operativo THEOS.
Se emplean dos variables
semáforos: Un mutex de no dejar
que un cliente tome la silla del
barbero, si esta se encuentra
ocupada. La otra variable cuenta el
número de clientes que esperan al
barbero, si hay más de 5 no deja
entrar otro cliente a la barbería,
hasta que se desocupe una silla.
En electrónica y en programación
concurrente, se conoce como
condición de carrera al error que se
produce en los programas o
circuitos lógicos que se han
construido adecuadamente para su
ejecución simultánea con otros
procesos. Fig. Nº 1

3. Fig. Nº 1
 Administración de buffers
Fig. Nº2
 Tendencia a llenarse de los
buffers (TCP windowing).
 Buffering reduce Loss,
introduce Delay.
 Overflow de buffers => se
descartan paquetes o frames.
 Para garantizar QoS se
deben pre alocar y reservar.
¿Qué hacer?
 Sobredimensionamiento
(Overprovisioning).
 Diseñar.
 Controlar y evitar. Fig. Nº 2
Soluciones
La presencia de congestión
significa que la carga 8 a
veces en forma temporaria es
mayor que los recursos.
Desde otro punto de vista
que podemos hacer:
 Incrementar los recursos BW
, Buffers.
 Decremento la carga.
 Implementación
Fig. Nº 3
Podemos encontrar una codificación
en java y en C++. Fig. Nº 3

4.  Codificación en c++.
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#define TRUE 1
#define FALSE 0
#define CHAIRS 3 //Sillas
Disponibles
#define CANT_CUST 5 //Cantidad
de Clientes
#define T_CUST 0 //Tiempo de
llegada de Clientes
#define T_CORTE 3 //Tiempo de
corte de pelo
typedef int semaphore;
//Prototipo de funciones
void *customer (void *);
void *barber (void *);
void up (semaphore *);
void down (semaphore *);
semaphore sem_barber=0,
sem_customer=0,sem_mutex=1;
int waiting=0;
//Main function
int main (void) {
pthread_t
barb_t,cust_t[CANT_CUST];
int i;
pthread_create(&barb_t,NULL,barbe
r,NULL)…
for (i=0;i<CANT_CUST;i++){
sleep(T_CUST);
pthread_create(&cust_t[i],NULL,cust
omer,…
}
pthread_join(barb_t,NULL);
return(0);
}
void *customer (void *n) {
printf ("Customer:entrando hay %d
esperandon",waiting);
down (&sem_mutex);
if (waiting < CHAIRS) {
waiting++;
up (&sem_customer);
up (&sem_mutex);
down (&sem_barber);
printf ("Customer:Me estan cortando
el pelo.n");
}
else {
up (&sem_mutex);
printf ("Customer:Me fui no hay
lugar.n");
}
}
void *barber (void *j) {
printf ("Barber:Empiezo a
trabajarn");
while (TRUE) {
down (&sem_customer);
down (&sem_mutex);
waiting--;
up (&sem_barber);
up (&sem_mutex);
printf ("Barber:Comienzo el corte de
pelo de un cliente quedan %d
esperando.n",waiting);
sleep (T_CORTE);
printf ("Barber:Termine de cortar el
pelo de un cliente quedan %d
esperando.n",waiting);
}
}
void up (semaphore *sem) {
*sem+=1;
}
void down (semaphore *sem) {
while (*sem<=0){};
*sem-=1;
}

5.  Codificación en java
package pbarberodormilon;
import
java.util.concurrent.Semaphore;
import java.util.Random;
public class PBarberoDormilon {
static int SILLAS=5;
public static Semaphore
clientes=new Semaphore(0);
public static Semaphore
barberos=new Semaphore(0);
public static Semaphore mutex
=new Semaphore(1);
public static int
clientesesperando=0;
public static Cliente c[]=new
Cliente[SILLAS];
public static Barbero b=new
Barbero();
private static Random r=new
Random();
public static class Barbero
extends Thread {
@Override
public void run(){
while (true) {
try {
clientes.acquire();
mutex.acquire();
clientesesperando--;
barberos.release();
mutex.release();
int aux=r.nextInt(1000);
Thread.sleep(aux);
System.out.println("Bar
bero cortando el pelo.");
} catch
(InterruptedException ex){
ex.printStackTrace();
}
}
}
}
public static class Cliente extends
Thread {
private int id;
public Cliente(int id){
this.id=id;
}
@Override
public void run(){
try {

6. mutex.acquire();
if(clientesesperando<SI
LLAS) {
clientesesperando++;
clientes.release();
mutex.release();
barberos.acquire();
System.out.println("C
liente " + id + " siendo pelado.
Clientes
esperando:"+clientesesperando);
} else {
mutex.release();
}
} catch
(InterruptedException ex){
ex.printStackTrace();
}
}
}
public static void main(String[]
args) throws InterruptedException {
for(int i=0;i<SILLAS;i++){
c[i]=new Cliente(i);
c[i].start();
}
b.start();
for(int i=0;i<SILLAS;i++){
try {
c[i].join();
} catch (InterruptedException
ex) {
ex.printStackTrace();
}
}
b.join();
}
}
III. CONCLUSIÓN
El problema del peluquero
dormilón, es un clásico de
la programación, se
propone la discusión
sobre cómo gestionar el
”tránsito'' por una
pequeña peluquería, por
parte de dos tipos de
procesos: el peluquero y
los clientes durante la
ejecución la interacción
entre el peluquero y un
cliente se puede producir
muy a menudo y que, por
tanto, deben establecerse
los mecanismos de
sincronización adecuados

7. para evitar que los dos
“colisionen'' dentro la
peluquería; es decir,
asegurar que uno sólo es
el que se mueve en cada
momento.
IV. REFERENCIAS
(pdf, 2013)
(PDF, 2014)
(TAREAS, 2014)
(WEB, 2006)
 Bibliografía
pdf. (2013). Obtenido de
http://tuxtor.shekalug.org/compartido/sopes1/manual%20barbero%20dor
milon.pdf
PDF. (2014). Obtenido de
lml.ls.fi.upm.es/pc/Anteriores/Examenes/1993sep/node4.html
TAREAS, B. (9 de SEPTIEMBRE de 2014). Obtenido de
http://www.buenastareas.com/materias/codigo-barbero-dormilon-y-
filosofos/0
WEB. (3 de DICIEMBRE de 2006). Obtenido de
http://unambaayquipacelestino.blogspot.com/