sémaphore du lecteur/redacteur

Version imprimable

dans le probléme de redacteur/lecteurs,les lecteurs sont prioritaires,de ce fait il existe un risque de famine.prposer une solution qui qui élimine la famine et qui rend les rédacteurs prioritaires sur les lecteurs.en d'autres terme,dés qu'un redacteur réclame l'accés à un fichier(ressource),il doit l'obtenir le plus tot possible.donc tout lecteur arrivé aprés la demande du rédacteur doit attendre,méme si des lecteurs utilsent encore le fichier:
solution:je n'ai utlisé que deux sémaphores mutex(pour proteger une variable comp_redacteur qui va étre consulté par les lecteurs et redacteurs)et redact(y'a pas une simultaniéte entre les redacteurs)
on va proceder par l'algorithme
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 process redacteur; begin Si un redacteur est en exécution alors se bloquer;{un seul redacteur accéde a la ressource} Sinon compteur_redacteur:=compteur_redacteur+1; ecrire(mettre à jour); compteur_redacteur:=compteu_redacteur-1; Si compteur_redacteur<>0 alors reveiller un redacteur{qui etait dans la fille d'attente} end ; process lecteur; begin Sicompteur_redacteur<>0 Alors ___;{mis dans la file d'attente} Sinon lire(consulter); reveiller un lecteur{un lecteur qui etait dans la file} end ;
NB:LES PROCESSUS S'EXéCUTENT EN PARALLéLE.
ma question
doit on declarer un sémaphore pour le lecteur je me pose cette question car quand un rédacteur arrive il doit absolument utiliser la ressource(prioritaire) méme si un redacteur arrive au méme temps que lui et méme si si y'a des lecteurs qui utilisent cette ressource(car plusieurs lecteurs accédent à la ressource simultanément) donc on doit mettre le lecteur dans une file d'attente mais dans quelle fille????? ça peut pas étre celle des redacteurs!! dans mutex???? mais c juste pour proteger la variable compteur_redacteur.
ALORS voila j'espére que cette fois c'est un peu plus lisible

02/01/2007, 16h10
nunch

Si j'ai bien compris ce que tu as écrit, il n'y a pas de mutex au niveau du lecteur. Dans ce cas tu risques d'avoir des lectures fantômes car tu empêches un lecteur d'accéder à la ressource pendant qu'on écrit dedans mais pas l'inverse: un rédacteur peut accéder à la ressource pendant qu'on la lit.
C'est à dire que si un lecteur lit par exemple un texte de deux paragraphes, pendant qu'il lit le premier un rédacteur peut venir modifier le second paragraphe. Le lecteur finira par lire le second paragraphe mais avec un texte qui n'est plus à jour.
Dans certains modèles les lectures fantômes ne posent pas de problème. Mais dans d'autres, si on se sert de ce qu'on a lu au préalable pour faire une mise à jour, la lecture fantôme peut par la suite provoquer l'écrasement de données avec des infos déjà périmées. Dans ce cas il faut que la lecture et l'écriture soient mutuellement exclusives.
02/01/2007, 16h27
chelsea23

d'accord on fait une exclusion mutuelle pour les lecteurs quand un redacteur souhaite accéder à la ressource mais dans quelle fils d'attente allons nous mettre le lecteur vu qu'on lui a pas assigné un sémaphore??
02/01/2007, 16h41
nunch

Et bien dans la file d'attente des lecteurs et s'il n'y en a pas tu la crées.
02/01/2007, 17h04
pseudocode

Ou bien utiliser un verrou "multiple Read / Single Write" avec priorité au Write.
C'est le type de verrou utilisé dans les bases de données.
02/01/2007, 17h30
chelsea23

et ce type de verrou est il applicable pour les semaphores??

Heu, je ne sais pas ce que tu entends par "applicable". On peut certainement en implementer un avec des semaphores, si c'est ca la question.

Perso, j'en ai fait un avec des mutex, en java (désolé):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
public class MultipleReadSingleWriteLock implements LockInterface {
	private int givenLocks;
	private int waitingWriters;
	private Object mutex;
	
	/**
	 * Create a new Lock
	 */
	public MultipleReadSingleWriteLock()	{
		mutex = new Object();
		givenLocks = 0;
		waitingWriters = 0;
	}
	
	/**
	 * Ask the lock for reading
	 */
	public void getReadLock() {
		synchronized(mutex)	{
			try	{
				while((givenLocks == -1) || (waitingWriters != 0)) mutex.wait();
			} catch(java.lang.InterruptedException e) {
				return;
			}
			givenLocks++;
		}
	}
	
	/**
	 * Ask the lock for writing
	 */
	public void getWriteLock() {
		synchronized(mutex) {
			waitingWriters++;
			try	{
				while(givenLocks != 0) mutex.wait();
			} catch(java.lang.InterruptedException e) {
				return;
			}
			waitingWriters--;
			givenLocks = -1;
		}
	}
	
	
	/**
	 * release the lock (reading or writing)
	 */
	private void releaseLock() {	
		synchronized(mutex)	{
			if(givenLocks == 0)	return;
				
			if(givenLocks == -1)
				givenLocks = 0;
			else
				givenLocks--;
			
			mutex.notifyAll();
		}
	}

    public void releaseReadLock() {
        releaseLock();
    }

    public void releaseWriteLock() {
        releaseLock();
    }

}

02/01/2007, 18h46
chelsea23

merci mais en java avec ces classes tous ça je crois que je pourrais pas le comprendre si vous avez un en pascal ça serait mieux
merci!
02/01/2007, 19h39
pseudocode

Mes souvenirs de Pascal remonte trop loin. P-e vaut-il mieux fermer cette discussion et en ouvrir une nouvelle dans la section "algorithmie"...