Discussion :

[chelsea23]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[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.

[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??

[nunch]

Et bien dans la file d'attente des lecteurs et s'il n'y en a pas tu la crées.

[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.

[chelsea23]

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

[pseudocode]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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();
    }

}

[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!

[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"...