1.

INTRODUCCIÓN
La siguiente práctica está en el área de la concurrencia y la sincronización, vamos a explorar
el tema de los semáforos, y como mediante esta técnica se logra organizar y sincronizar los
procesos para que se ejecuten de manera correcta y ordenada en el procesador asignado
para esta tarea, para esto estudiaremos el problema de los productores y consumidores.

Como se mencionó el estudio de estos problemas es importante para la comprensión

correcta del funcionamiento y ejecución de los procesos mediante este recurso, es de gran
importancia crear una percepción de como funcionan estos mecanismos creados para la
resolución de estos problemas, ya que visualizarlo seria muy complejo ya que son tratados a
nivel del procesador y a una velocidad muy alta en la que no podríamos captar su función,
pero estos ejercicios mentales nos acercan a la lógica que se pretende utilizar y mediante la
cual se formularon resoluciones a los mismos.

Realizaremos la practicas de corroboración mediante pruebas de escritorio, con una

metodología de practica y experimentación.

2. ANÁLISIS TEÓRICO
a. Definición del problema del productor y consumidor
El problema Productor/Consumidor consiste en el acceso concurrente por parte de procesos
productores y procesos consumidores sobre un recurso común que resulta ser un buffer de
elementos. Los productores tratan de introducir elementos en el buffer de uno en uno, y los
consumidores tratan de extraer elementos de uno en uno.
Para asegurar la consistencia de la información almacenada en el buffer, el acceso de los
productores y consumidores debe hacerse en exclusión mutua. Adicionalmente, el buffer es
de capacidad limitada, de modo que el acceso por parte de un productor para introducir un
elemento en el buffer lleno debe provocar la detención del proceso productor. Lo mismo
sucede para un consumidor que intente extraer un elemento del buffer vacío. (Antologia
S.O., 2010)
b. Aproximación errónea del problema
El problema de la aproximación errónea es básicamente cuando se cae en lo que llamamos
deadlock, o como se lo ha mencionado interbloqueo, en este ejemplo particular de el
problema de Productor/Consumidor, cuando dos procesos quieren acceder al mismo recurso
al mismo tiempo, o en este caso podría producirse cuando se requiere un elemento que no
existe, por ejemplo, si el consumidor requiere un elemento no producido.

Como ya se mencionó, el problema con esta aproximación es que puede caer en un

deadlock, considere el siguiente escenario

El consumidor acaba de consultar la variable itemCount, nota que es cero y pasa a ejecutar
el bloque if.
2. Justo antes de llamar a la función sleep() el consumidor es interrumpido y el
productor comienza a trabajar.
3. El productor crea un objeto, lo agrega al buffer y aumenta itemCount.
4. Como el buffer estaba vacío antes de la última adición el productor intenta despertar
al consumidor.
5. Desafortunadamente el consumidor no estaba durmiendo todavía luego la llamada
para despertarlo se pierde. Una vez que el consumidor comienza a trabajar
nuevamente pasa a dormir y nunca más será despertado. Esto pasa porque el
productor solo lo despierta si el valor de itemCount es 1.
6. El productor seguirá trabajando hasta que el buffer se llene, cuando esto ocurra se
pondrá a dormir también.
Como ambos procesos dormirán por siempre, hemos caído en un deadlock. La esencia del
problema es que se perdió una llamada enviada para despertar a un proceso que todavía no
estaba dormido. Si no se perdiera, todo funcionaría. Una alternativa rápida seria agregar un
bit de espera de despertar a la escena. Cuando se envía una llamada de despertar a un
proceso que está despierto, se enciende este bit. Después, cuando el proceso trata de
dormirse, si el bit de espera de despertar está encendido, se apagará, pero el proceso
seguirá despierto. El bit de espera de despertar actúa como una alcancía de señales de
despertar. Aunque el bit de espera de despertar soluciona este caso, es fácil construir
ejemplos con tres o más procesos en los que un bit de espera de despertar es insuficiente.
Se podría agregar un segundo bit de
espera de despertar, o quizá 8 o 32, pero en principio el problema sigue ahí. (Correia
Barbosa, 2019)
c. Tipos de soluciones implementadas
Una de las implementaciones para resolver este problema es el uso de semáforos, también
adjunto a esto se pueden utilizar instrucciones propias en los lenguajes en que están
descritos, de esta manera se garantiza la ejecución de uno de los procesos a la vez.

Hay un solo emisor y un solo receptor y las operaciones que realizan son enviar y recibir
respectivamente. La información que se envía se pasa a través de una variable compartida,
en este caso valor, por lo que el buffer de comunicación tiene longitud uno. El protocolo es
síncrono, esto quiere decir que el primer proceso, ya sea el productor o el consumidor que
llega a la cita tiene que esperar al otro. (Amoros, 2019)

Como ya se mencionó estos problemas no simplemente son aplicados a los procesos básicos
y a las señales y funciones atómicas, de hecho, se puede extrapolar a fin de conseguir
comprender el problema y llevarlo a otros escenarios.

A continuación, se muestra el codigo fuente de una de las soluciones aplicadas a estos

temas, es necesario considerar que está hecho en el lenguaje C++, sin embargo, existen
variante y además se han escrito en diferentes lenguajes de programación.
3. ANÁLISIS DEL ALGORITMO DE PRODUCTORES Y CONSUMIDORES
#include <sys/types.h>
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

semaphore n;//Declaración de objeto tipo semáforo

semaphore s;//Declaración de objeto tipo semáforo

process f_productor() {
while(true) { //Mientras sea verdad proceda
producir_datos();
wait(s);//Envía un señal, solicitud de token
aniadir_dato_buffer();//Entrada a Sección critica
signal(s);//Indica que la sección critica esta liberada
signal(n);//Indica que la sección critica esta liberad
}
}

process f_consumidor() {
while(true) { //Mientras sea verdad proceda
wait(n);//Envía una señal, solicitud de token para verificar si
alguno está listo
wait(s);//Envía una señal, solicitud de token para verificar si
alguno está listo
tomar_dato(s);
signal(s);//Indica que la sección critica esta liberada
consumir_dato(s);//Entrada a Sección critica
}
}

main() { //Inicio de la sección Principal

initsem(s, 1);//Inicializa el contador a 1, además se le pasa el
parametro el proceso
initsem(n, 0);//Inicializa el contador a 0, además se le pasa el
parametro el proceso

cobegin { //Función que permite que cada instrucción se ejecute una

por vez
f_productor();//Llamada a procedimiento productor
f_consumidor();//Llamada a procedimiento consumidor
}
}
4. CONCLUSIONES

Existen varios problemas mediante los que la aplicación de semáforos posibilita la

resolución de los mismo, en si los problemas presentados son tipos de ejemplos y
ejercicios mentales, que muestran de manera explicita lo que sucede con la concurrencia
en entre los procesos al ser ejecutados, además se muestran resoluciones a estos
problemas, y explicaciones mediante código de programación, aunque realmente todo
esto funciona a nivel de ensamblador, sin embargo, es posible emularlo con código.

El tema tratado se explica bastante bien, de hecho, el código de programación en c++ es

bastante explicativo y hay suficiente información en la red para referenciarse a él,
utilizando la prueba de escritorio podemos ver de manera puntual y ralentizada para una
explicación objetiva acerca del funcionamiento de los semáforos, aparte de la explicación
que se dio en el video de cada línea de código.

BIBLIOGRAFÍA
Amoros, F. (2019). PROGRAMACION CONCURRENTE. Obtenido de https://fdocuments.ec/:
https://fdocuments.ec/document/programacion-concurrente-universidad-nacional-de-
ejemplo-m-as-conocido-quiz.html

Antologia S.O. (08 de 04 de 2010). Problema Productor-Consumidor. Obtenido de

https://antologiaso.wordpress.com:
https://antologiaso.wordpress.com/2010/04/08/problema-productor-consumidor/
Correia Barbosa, M. (2019). GARANTIZANDO EL ACCESO CONCURRENTE DE MÚLTIPLES PROCESOS A
UN BUFFER LIMITADO. Obtenido de https://revistas.unica.cu:
https://revistas.unica.cu/index.php/uciencia/article/view/1181/2047