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