Problema cititorilor şi

scriitorilor

Popa Andreea
Vid Alexandru
Problema cititor-scriitor

 În informatică, problema cititor-scriitor este un

exemplu tipic de rezolvare a problemei concuren ţei.ei
 Problema tratează situaţia în care mai multe thread-
uri (fire de execuţie) împart aceeaşi zonă de
memorie în acelaşi interval de timp, unul citind şi
altul scriind.

 Acestă problemă modelează accesul la o bază de

date.
Enunţul problemei(1)

 Se consideră o bază de date la care au

acces mai mulţi cititori şi mai mulţi scriitori.
 Este permis ca mai mulţi cititori să aibă acces
simultan la conţinutul bazei de date, dar dacă
un scriitor operează asupra bazei de date
(completează, şterge, modifică, etc.) atunci
nici un alt scriitor şi nici un alt cititor nu au
acces la ea.
Enunţul problemei(2)
 Mai exact:
- un cititor poate începe operaţia de citire dacă
şi numai dacă nici un scritor nu este în curs
de a scrie în baza de date;
- un scriitor poate începe operaţia de scriere
dacă şi numai dacă nici un cititor şi nici un alt
scriitor nu au acces la baza de date.
Se cere să se simuleze operaţiile de citire şi
scriere în baza de date.
Producator-consumator vs.
Cititor – scriitor (1)

 Cele două probleme se aseamană prin faptul

că cele două fire de execuţie de tipuri diferite
(producător consumator, respectiv cititor
scriitor) nu pot accesa în acelaşi tip zona de
memorie, respectiv baza de date.
Producator-consumator vs.
Cititor – scriitor (2)
 În problema producător-consumator, dacă
cele două procese au acces în acelaşi timp la
zona de memorie, atunci consumatorul poate
prelua de mai multe ori acelaşi produs
deoarece producătorul nu a apucat să
producă alt produs.
 De asemenea producătorul poate suprascrie
acelaşi produs fără ca acesta să fie preluat
de consumator, astfel pierzându-se anumite
produse.
Producator-consumator vs.
Cititor – scriitor (3)
 În problema cititor-scriitor, dacă cele două
procese (procesul de citire şi procesul de
scriere) au acces la baza de date în acelaşi
timp, se poate întâmpla ca cititorul să
citească o zonă de memorie care este în curs
de scrie.
 Acest fapt va duce la blocarea bazei de date.
Variante de rezolvare a
problemei cititor-scriitor
Pentru această problemă sunt mai multe
metode de rezolvare:

 Cititorii au prioritate;
 Scriitorii au prioritate;
 Cititorii comunică cu scriitorii prin mesaje.
Cititorii au prioritate
 În acest caz scriitorii sunt lasaţi la urmă.
 Incepe un cititor să citească din baza de
date. Dacă un scriitor ajunge după el, acesta
trebuie să aştepte pană când cititorul termină.
 Dacă un alt cititor vrea să citească, acesta
are dreptul de a intra şi de a citi. Scriitorul
încă aşteaptă.
 Scriitorul va trebui să aştepte până când toţi
cititorii termină de citit.
Cod Sursă C
int readcount = 0; void reader()
semaphore wsem = 1; {
//semaphore x = 1; while(1)
void main()
{
{
int p = fork(); wait(x);
if(p) readcount++;
reader; // presupune instante multiple if (readcount==1)
else
writer; // presupune instante multiple wait(wsem);
} signal(x);
doReading();
void writer() wait(x);
{
while(1)
readcount- -;
{ if (readcount==0)
wait(wsem)
doWriting(); signal(wsem);
signal(wsem) signal(x);
} }
} }
Scriitorii au prioritate
 În acest caz, scriitorul nu este nevoit să aştepte ca
cititorii care vin după el să citească.
 Scriitorul aşteaptă doar ca cititorii activi, care a ajuns
înaintea lui, să termine de citit.
 Cititorii care ajung după scriitor vor aştepta ca
acesta să termine de actualizat baza de date.

 Prin acestă metodă se micşorează concurenţa, deci

avem o performanţă mai slabă.
Cod Sursă C
if (readcount==1)
if (readcount==1)
int readcount, writecount = 0;
wait(wsem);
semaphore rsem, wsem = 1; signal(x);
//semaphore x,y,z = 1; signal(rsem); wait(wsem);
void main() signal(z);
doWriting();
{ doReading();
wait(x); signal(wsem);
int p = fork();
readcount--; wait(y);
if(p)
if (readcount==0) writecount- -;
reader; // presupune instante multiple
signal(wsem); if (writecount==0)
else signal(x); signal(rsem);
writer; // presupune instante multiple } signal(y);
} }
}
void reader() void writer()
{
}
{
while(1) while(1)
{
{
wait(y);
wait(z); writecount++;
wait(rsem); if (writecount==1)
wait(x); wait(rsem);
readcount++; signal(y);
Comunicarea prin mesaje
 Rezolvările acestei probleme se realizează
cu ajutorul înfometării (adică unui proces îi
este refuzat accesul la anumite resurse în
mod repetat – procesul are şanse să nu se
execute niciodată) .

 Această metodă încearcă să rezolve

problema, astfel încât nici un proces să nu fie
supus înfometării.
 Cod Sursă C
void reader(int id) rmsg = id; }
{ send("Finis",rmsg); }
message rmsg; }
if(count==0) { //doar un scriitor
while(1) }
{ void controller() send("Writer"+id, "OK");
rmsg = id; { receive("Finis",msg);
end("ReadReq",rmsg); while(1) count = MAXREADERS;
receive("Reader"+id,rmsg); { }
DoReading(); if(count>0){ //nu sunt scriitori
while(count<0) {
rmsg = id; if (!empty("Finis")) {
send("Fini",rmsg); receive("Finis",msg); receive("Finis",msg);
} count++; count++;
} } }
void writer(int id) else if(!empty("WriteReq")) { }
{ receive("WriteReq",msg);
}
message rmsg; id = msg.id;
while(1) count -= MAXREADERS;
{ }
rmsg = id; else if(!empty("ReadReq")) {
send("WriteReq",rmsg); receive("ReadReq",msg)
receive("Writer"+id,rmsg); count--;
DoWriting(); send("Reader"+msg.id, "OK");
Bibliografie

 A. Tanenbaum – Sisteme de operare

moderne – editia a 2-a

 www.google.ro