1. UNIVERSIDAD TECNICA DE AMBATO
FACULTAD DE CIENCIAS
HUMANAS Y DE LA EDUCACION
SISTEMAS OPERATIVOS
TEMA: LECTORES Y ESCRITORES
INTEGRANTES:
•PABLO FALCONI
•STALIN PALLANGO
•SANTIAGO TIXILEMA

2. DESCRIPCION DEL PROBLEMA
Pero nunca ocurrirá
Solo puede utilizar simultáneamente
Hay un objeto de
el recurso un (teniendo en cuenta
datos(fichero de
proceso y solo que si no lo esta
texto) que es
uno, es decir, o bien utilizando
utilizado por varios
un proceso estará nadie, tendrá
procesos, unos leen
escribiendo o bien preferencia el
y otro que escribe.
leyendo escritor antes que el
lector).

3. DOCUMENTACION DEL PROGRAMA
Se considera a cada
usuario como dos La solución de este
Se considera a cada semáforos. Estos problema se basa en
usuario(lector y semáforos son implementar un
escritor) como dos binarios y valen 0 si algoritmo en el
procesos y al fichero el recurso (fichero) manejo de
en cuestión como está siendo utilizado semáforos y
un recurso. por otro proceso y 1 memoria
si dicho recurso está compartida.
disponible.

4. PARA QUE EL PROBLEMA ESTÉ BIEN
RESUELTO SE TIENE QUE CUMPLIR:
Cuando un escritor
debe realizar su
No se puede hacer
tarea, debe ocurrir
esperar a ningún
cuanto antes, sin
proceso lector si
que deban interferir
ningún proceso
los procesos
escritor accede al
lectores.(Para ello se
recurso.
establecen
prioridades)

5. ALGORITMO LECTORES-ESCRITORES
Lector (){
while (TRUE){
Sección no crítica
wait(semáforo1)
contador++;
if (contador =1)
wait(semáforo2)
signal(semáforo1)
Acceso al recurso (LECTURA)
wait(semáforo1)
contador--
if (contador=0)
signal(semáforo2);
signal (semáforo1)
}
}
Escritor(){
while (TRUE){
Sección no crítica
wait (semáforo2)
Acceso al recurso
signal (semáforo2)
}
}

7. FUNCION MAIN:
Creación de un proceso padre y de su proceso hijo (lectores, escritores).
DESCRIPCION
escribir( ); Esta función implementa el acceso a un recurso compartido, que
será la variable que contabiliza el total de veces que el usuario escribe. En
esta función se han incluido varias llamadas al macro TP. Este macro
implementa un retardo aleatorio con el fin de dar cierto tiempo a que ocurran
interrupciones que puedan detener la ejecución del proceso en su "cuanto"
de tiempo asignado por el S.O.. En nuestro caso, es necesario realizar unas
cuantas llamadas para dar tiempo a que todos los usuarios tengan
oportunidad de escribir.
lectura( ); Permite que el lector pueda acceder al recurso. Una vez que
acaba de leer se encarga de dejar el recurso para que sean de nuevo
utilizado (por él o por otros). Para ello se basa en funciones de manejo de
semáforos y memoria compartida.

8. Utiliza las siguientes funciones:
Manejo de semaforos:
•semWait ( )
•semSignal ( )
•semOpen ( )
•semClose ( )
Manejo de memoria compartida:
Cada vez que escribe un usuario lo refleja en el incremento de la variable de
memoria compartida.
Cuando los lectores y escritores han realizado la tarea que desean(leer y escribir)
un número M de veces prefijado (3) se lo comunican al padre, no sin antes haber
cerrado adecuadamente todos los semáforos utilizados en esta función.

9. LECTORES.C
#include "rshmem.h"
#include <string.h>
#include <stdio.h>
int main(int argc, char *argv[]){
/*DECLARACION DE VARIABLES*/
int contador=0;
FILE *fpl,*fpe;
int i,n;
char texto [250],c;
int mutex_s; /*semáforo 1*/
int mutex_w; /*semáforo 2*/
key_t claveMutex_s; /*clave semáforo 1*/
key_t claveMutex_w; /*clave semáforo 2*/

10. /*CONTROL DEL PASO DE ARGUMENTOS*/
if(argc!=2){
fprintf(stderr,"main:error en el paso de argumentosn");
exit(3);
}
/*obtener una clave cualquiera para el recurso ipc*/
if((key_t)-1==(claveMutex_s = ftok("lectores.c",'s'))){
fprintf(stderr,"main:Error al crear la clave con ftokn");
exit(1);
}
if((key_t)-1==(claveMutex_w = ftok("lectores.c",'s'))){
fprintf(stderr,"main:Error al crear la clave con ftokn");
exit(1);
}

11. /*crear el semáforo*/
if(-1==(mutex_s=semCreate(claveMutex_s,1))){
fprintf(stderr,"main:No se puede crear el semáforo 1n");
exit(1);
}
if(-1==(mutex_w=semCreate(claveMutex_w,1))){
fprintf(stderr,"main:No se puede crear el semáforo 2n");
exit(1);
}
/*crear zona de memoria compartida*/
if(!crearMemoria())
fprintf(stderr,"Error al crear memoria compartidan");

12. if(0!=fork()){ /*PROCESO ESCRITOR*/
if((fpl=fopen(argv[1],"r+"))==NULL){
printf("Error en la apertura del fichero %s n",argv[1]);
exit(-1);
semClose(mutex_w);
}
rewind(fpl);
for(i=0;i<3;i++){
printf ("Dime una frase que quieras escribir:");
gets(texto);
n=strlen(texto);
semWait(mutex_w);
fwrite(texto,(n*sizeof(char)),1,fpl);
semSignal(mutex_w);
semClose(mutex_w);
exit(0);
}
fclose(fpl);
}
else{

13. /* PROCESO LECTOR*/
if((fpe=fopen(argv[1],"w"))==NULL){
fprintf(stderr,"Error no se puede abrir el fichero %s n",argv[1]);
semClose(mutex_w);
semClose(mutex_s);
exit(2);
}
for(i=0;i<3;i++) {
semWait(mutex_s);
contador ++;
if(contador==1)
semWait(mutex_w);
while(!feof(fpe)){
semSignal(mutex_s);
fread((char *)c,sizeof(char),1,fpe);
semWait(mutex_s);
printf("%c",c);
}
contador --;
if(contador==0)
semSignal(mutex_w);
semSignal(mutex_s);
semClose(mutex_s);

14. semClose(mutex_w); /*CERRAMOS LOS
FICHEROS*/
fclose(fpe);
}
/*eliminamos memoria compartida*/
if(!eliminarMemoria()){
fprintf(stderr,"Error al eliminar la memoria compartida");
exit(9);
}
}
return (0);
}