Lectores Y Escritores
Introducción
Podremos imaginar este problema como una base de datos, con muchos procesos en
competencia, que obviamente intentan escribir y leer en ella.
De manera que existe un área compartida entre los procesos donde algunos únicamente
leen los datos (Lectores) y otros solamente escriben datos (Escritores).
Problemática
Existe una base de datos que comparten una serie de procesos, existen 2 procesos
principales:
1) Lectores: Este proceso se encarga de leer solo el contenido de la base de datos
2) Escritores: Este proceso se encarga de escribir datos en la base de datos.
E L EL L
BD
El problema surge al querer cumplir las siguientes condiciones:
a) Cualquier número de lectores puede leer datos simultáneamente.
b) En la base de datos sólo puede escribir un escritor en cada instante.
c) Si un escritor está accediendo a la base de datos, ningún lector puede leerlo.
El problema en general radica en exclusión mutua, ya que consiste en permitir a
cualquiera de los procesos (lectores o escritores) leer o escribir en el área de datos (entrar
en la región crítica).
Esto hace necesario declarar cualquier acceso como una sección crítica donde los
procesos tendrían que acceder uno a uno produciéndose intolerables retrasos, además se
debe impedir que los escritores interfieran unos con otros y también que se realicen
consultas mientras se llevan a cabo modificaciones.
SOLUCIÓN
Para solucionar el problema se propone la realización de un nuevo método denominado
guardia que será el encargado de dar entrada a la región crítica ya sea a procesos lectores
o escritor.
Dentro del cual se tendrán comparaciones con un arreglo denominado fila que
simulara la fila de los procesos que desean entrar a leer o escribir en la base de datos o
región critica. Así mismo se planea que exista ese efecto de movimientos de lugar dentro
de las filas esto ayudara al método guardia a definir qué proceso desea entrar y qué
proceso sale de la región critica.
Para ello se propone el siguiente algoritmo:
1=Lectores 2=Escritores
Type int esc=0;
Type int rc=0;
Fila[]=10 //posiciones que existen en la fila
Type int semaphore
Semaphore mutex=1
Semaphore db=1
Void guardia(){
If((fila[0]==1)&&(esc==0)){
Reader();
} else{
If((fila[0]==2)&&(rc==0) ){
Esc=esc+1
Writer();
}//end if
}//end else
}
Void reader(void){
While(true){
Down(&mutex); //obtener acceso exclusive a RCritica
Rc=rc+1; //un lector mas
If(rc==1) down(&db); //si es el 1er lector
Up(&mutex); //libera el acceso exclusivo a rc
Read_data_base(); //accede a los datos
Down(&mutex); //obtener acceso exclusive a rc
Rc=rc-1;//un lector menos
If(rc==0) up(&db) // si este es el ultimo lector
Up(&mutex); //liberar el acceso exclusivo a rc
Use_data_read(); //región no critica
}
}
Void writer(void){
While(true){
Think_up_data(); //region no critica
Down(&db); //obtener acceso exclusive
Write_data_base(); //actualizar datos
Up(&db); //liberar el acceso exclusive
Esc=esc-1
}
}
CONCLUSIÓN
Top Related