Discussion:Problème des lecteurs et des rédacteurs

Autres discussions [liste]

Admissibilité
Neutralité
Droit d'auteur
Article de qualité
Bon article
Lumière sur
À faire
Archives
Commons

Cet article est indexé par le projet Informatique.

Les projets ont pour but d’enrichir le contenu de Wikipédia en aidant à la coordination du travail des contributeurs. Vous pouvez modifier directement cet article ou visiter les pages de projets pour prendre conseil ou consulter la liste des tâches et des objectifs.

**Évaluation** de l’article « **Problème des lecteurs et des rédacteurs** »
Avancement	Importance	pour le projet
Bon début	Faible		Informatique (discussion • critères • liste • stats • hist. • comité • stats vues)

Cet article ne comporte pas de liste de tâches suggérées. Vous pouvez saisir une liste de tâches à accomplir (par exemple sous forme d'une liste à puces), puis sauvegarder. Vous pouvez aussi consulter la page d'aide.

Priorité aux lecteurs == famine des rédacteurs[modifier le code]

Pour reprendre le titre, la priorité aux lecteurs tels qu'implémenté dans la solution proposé pose un problème de famine pour les rédacteurs. Avoir le code sous les yeux peut aider, donc le je remet ici :

Commencer_Lire :
   P(M_Lect)
   Lect++
   SI Lect==1 ALORS
      P(Red)
   FIN SI
   V(M_Lect)

Finir_Lire :
   P(M_Lect)
   Lect--
   SI Lect==0 ALORS
      V(Red)
   FIN SI
   V(M_lect)

Commencer_Ecrire
   P(M_Red)
   P(Red)

Finir_Ecrire
   V(Red)
   V(M_Red)

En effet si il arrive un flux continu de lecteurs, la variable Lect n'est jamais égale à 0 et donc il n'y aura jamais de V(Red) pour libérer les rédacteurs. Moi je propose de modifier Commencer_Lire comme ceci :

Commencer_Lire :
   P(M_Red)
   V(M_Red)
   P(M_Lect)
   Lect++
   SI Lect==1 ALORS
      P(Red)
   FIN SI
   V(M_Lect)

De cette façon la file d'attente principale des processus est gérée par le mutex M_Red on peut ainsi garantir que le premier arrivé sur le P(M_Red) sera le premier servi (si le sémaphore est bien implémenté, mais on suppose que oui), et ce quelque soit le type du processus (lecture ou écriture). Pour le coup il faudrait redéfinir la sémantique du mutex M_Red.

Je soumet donc cette solution à votre sagacité au cas où ceci ne marcherait pas pour une raison ou une autre. 90.45.227.227 31 août 2007 à 01:58 (CEST)[répondre]

Pour être honnête, c'est un peu logique qu'il puisse y avoir famine des rédacteurs, puisque la priorité est forcément donnée aux lecteur dans cette solution. Tant qu'il y a des lecteurs, ils doivent passer devant les rédacteurs. Changer ce principe conduirait à ne plus avoir la priorité au lecteur. Boretti(me parler) 31 août 2007 à 22:23 (CEST)[répondre]

C'est pas faux, mais est-ce une bonne idée de donner la priorité aux lecteurs sachant que la famine des rédacteurs constitue le deuxième problème des lecteurs/rédacteurs si j'en crois l'article anglais en:Readers-writers_problem ? Les solutions qui donnent la priorité à l'un ou l'autre ne sont pas totalement à exclure selon le contexte d'utilisation (notamment le ratio lecteur/rédacteur), mais si on veut être un peu général ne faudrait-il pas éviter toutes les famines ? Enfin bon je dis ça je dis rien, la plupart des articles concernant la programmation concurrente sont à compléter. 90.45.24.244 1 septembre 2007 à 05:14 (CEST)[répondre]

Oui et non. En fait, l'idée était de donner un exemple ; rien de plus. Après rien n'empêcherait de faire un exemple avec priorité aux rédacteurs ou priorité égale lecteur/rédacteur puis de comparer les solutions en terme de famine ou d'autres aspects. Boretti(me parler) 1 septembre 2007 à 09:21 (CEST)[répondre]