Ingenierı́a Informática.

Sistemas Operativos I
Tema 4. Concurrencia entre procesos. Problemas

Sincronización de procesos mediante semáforos

1. Escribir un programa en C que lea desde el teclado dos enteros, ini y fin (varibles globales),
y cree dos procesos ligeros que serán procesos que se estarán ejecutando concurrentemente
en el sistema. Cada proceso deberá realizar la siguiente tarea:

• Hilo 1: Calculará la suma de los enteros compredidos en la primera mitad del intervalo
(entre ini y fin-ini/2). El resultado parcial obtenido lo acumulará sobre la variable
global suma.
• Hilo 2: Calculará la suma de los enteros compredidos en la segunda mitad del intervalo
(entre (fin-ini/2)+1 y fin). El resultado parcial obtenido lo acumulará sobre la variable
global suma.
• La hebra principal esperará a que acaben cada uno de los procesos creados (hilos) e
imprimirá la variable global suma.

El control del acceso a la sección crı́tica se deberá realizar mediante semáforos.

2. Escribir un programa en C que cree dos procesos ligeros, llamados H1 y H2 (procesos con-
currentes). Cada proceso debe ralizar la siguiente tarea:

• El proceso padre creará los dos hilos y debe imprimir por pantalla los números del 11
al 15.
• H1 imprimirá por pantalla los números del 0 al 5 y finalizará su ejecución.
• H2 imprimirá por pantalla los números del 6 al 10 y finalizará su ejecución.

Los números deberán imprimirse en orden creciente. La sincronicación necesaria entre los
dos procesos se realizará mediante semáforos.

3. Escribir un programa en C que cree dos procesos ligeros, llamados H1 y H2 (procesos con-
currentes). Cada proceso debe realizar la siguiente tarea:

• El proceso padre creará los dos hilos y debe imprimir por pantalla los números del 21
al 25.
• H1 imprimirá por pantalla los números del 0 al 5 y del 11 al 15 y finalizará su ejecución.
• H2 imprimirá por pantalla los números del 6 al 10 y del 16 al 20 y finalizará su ejecución.

Los números deberán imprimirse en orden creciente. La sincronicación necesaria entre los
dos procesos se realizará mediante semáforos.
4. Escribir un programa en C que cree dos procesos ligeros, llamados H1 y H2 (todos se estarán
ejecutando concurrentemente en el sistema). Cada proceso debe realizar lo siguiente:

• El proceso padre creará los dos hilos y se quedará esperando a que acaben para finalizar
su ejecución.
• H1 se encargará de generar los números pares comprendidios entre 0 y 50 e imprimirlos
por pantalla.
• H2 se encargará de generar los números impares comprendidios entre 0 y 50 e imprim-
irlos por pantalla.

Los números deberán imprimirse en orden creciente. La sincronicacion necesaria entre los
dos procesos se realizara mediante semáforos.

5. Sean los dos siguientes procesos que constan de las siguientes partes:

Hilo A Hilo B
Parte A1 Parte B1
Parte A2 Parte B2
Parte A3 Parte B3
Parte A4 Parte B4

Reescribir el código de estos procesos ligeros de tal forma que la ejecución de ambos debe
sincronizarse ( mediante la utilización de semáforos) de la siguiente forma:

• Parte A2 debe ejecutarse tras A1 y B1

• Parte A3 debe ejecutarse tras A2 y B2.
• Parte B3 tras B2 y A2.
• Parte A4 tras A3 y B3.
• Parte B4 tras B3 y A3.

6. Estudiar la validez del siguiente código:

#define MAX 10;

#define true 1
#define false 0;

sem_t mutexA, mutexB, procA, procB;

int numA, numB;

int bucleA, bucleB; /*valores true or false*/

/*Código hilos Tipo A */

void procesosA (int k)
{
 sem_wait (&procA);
sem_wait (&mutexA);
numA:=numA+1;
if (numA==1) sem_wait (&procB);
bucleA=true;
while (bucleA)
bucleA=(numB>0);
sem_post (&mutexA);
sem_post (&procA);
/* Acceso a datos comunes */
sem_wait (&mutexA);
numA=numA-1;
if (numA==0) sem_post (&procB);
sem_post (&mutexA);
}

/*Código hilos tipo B*/

void procesosB(int k)
{
sem_wait (&procB);
sem_wait (&mutexB);
numB:=numB+1;
if (numB==1) sem_wait (&procA);
bucleB:=true;
while (bucleB)
bucleB:=(numA>0);
sem_post (&mutexB);
sem_post (&procB);
/* Acceso a datos comunes */
sem_wait (&mutexB);
numB:=numB-1;
if (numB==0) sem_post (&procA);
sem_post (&mutexB);
}

main()
{
pthread_t thA[MAX], thB[MAX]; /* identificadores de threads */

numA:=0; numB:=0;

/* Inicializar semaforos */
sem_init (mutexA,0,1); sem_init (mutexB,0,1);
sem_init (procA,0,1); sem_init (procB,0,1);
 /*crear procesos tipo A */
for (k=0;k<MAX;k++)
pthread_create(&thA[k], NULL, ProcesosA, k);
/*Crear procesos tipo B */
for (k=0;k<MAX;k++)
pthread_create(&thB[k], NULL, ProcesosB, k);

/*esperar su finalizacion */
for (k=1;k>=MAX;k++) {
pthread_join(&thA[k], NULL));
pthread_join(&thB[k], NULL));
}

/* Destruir los semaforos */

sem_destroy(&mutexA); sem_destroy(&mutexB);
sem_destroy(&procA); sem_destroy(&procB);

exit(0);
}

7. En una senda de montaña se ha construido un puente que es capaz de resistir 750 kilos.
Suponer que tenemos una aplicación con múltiples procesos en la que cada proceso representa
a un excursionista. Diseñar el código que deben ejecutar los procesos antes y después de
cruzar el puente para que, sin que el puente se hunda y respetando el orden en el que
llegan los excursionistas, lo puedan cruzar simultáneamente el máximo número posible de
excursionistas. Considerar que cada proceso tiene una variable local denominada mipeso
que contiene el peso del excursionista al que representa.