correction des thread sleep

lecteursredacteurs/lecteursredacteurs.iml

@@ -11,5 +11,9 @@
     </content>
     <orderEntry type="inheritedJdk" />
     <orderEntry type="sourceFolder" forTests="false" />
+    <orderEntry type="library" name="Maven: org.junit.jupiter:junit-jupiter-api:5.6.0" level="project" />
+    <orderEntry type="library" name="Maven: org.apiguardian:apiguardian-api:1.1.0" level="project" />
+    <orderEntry type="library" name="Maven: org.opentest4j:opentest4j:1.2.0" level="project" />
+    <orderEntry type="library" name="Maven: org.junit.platform:junit-platform-commons:1.6.0" level="project" />
   </component>
 </module>

lecteursredacteurs/pom.xml

@@ -7,6 +7,14 @@
     <groupId>ch.heigvd.to</groupId>
     <artifactId>lecteursredacteurs</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <dependencies>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.6.0</version>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
     <packaging>pom</packaging>
 
     <properties>

lecteursredacteurs/src/main/java/Controleur.java

@@ -0,0 +1,55 @@
+public class Controleur {
+
+    private int redacteurs = 0;
+    private int redacteursAttente = 0;
+    private int lecteurs = 0; // Nombre de lecteurs en train de lire
+
+    public synchronized void startRead() {
+
+        // Si il y a un rédacteur en train d'écrire -> thread en attente
+        while (redacteurs > 0 || redacteursAttente > 0) {
+            try {
+                this.wait();
+            } catch (InterruptedException e) {
+            }
+        }
+        lecteurs++;// Un lecteur supplémentaire
+    }
+
+    public synchronized void stopRead() {
+        /*
+        un lecteur actif en moins, si il n'y en
+        a plus, on libère tout les threads en wait avec notifyAll
+         */
+        lecteurs--;
+        if (lecteurs == 0) this.notifyAll();
+
+    }
+
+    public synchronized void startWrite() {
+        redacteursAttente++;
+        /* Si il y a encore un lecteur en train de lire
+         ou un autre redacteur en train d'écrire
+         le thread est en attente.
+         */
+        while ((lecteurs > 0 || redacteurs > 0)) {
+            try {
+                this.wait();
+            } catch (InterruptedException e) {
+            }
+        }
+        redacteurs++;
+        redacteursAttente--;
+    }
+
+    public synchronized void stopWrite() {
+        /*
+        un lecteur actif en moins, si il n'y en
+        a plus, on libère tout les threads en wait avec notifyAll
+         */
+        redacteurs--;
+        if (lecteurs == 0) this.notifyAll();
+    }
+}
+
+

lecteursredacteurs/src/main/java/Lecteur.java

@@ -0,0 +1,43 @@
+/*
+porblème avec l'utilisation de thread sleep car les assert ne marche pas à tout les coup.
+ */
+
+public class Lecteur implements Runnable {
+
+    private Controleur controleur;
+    private boolean enAttente = false;
+
+    public Lecteur(Controleur c) {
+        controleur = c;
+    }
+
+    public void run(){
+        // si le controleur n'a pas commencé, le lecteur est en attente
+         enAttente = true;
+        {
+            controleur.startRead();
+        }
+        // si il est en train de lire il n'est plus en attente
+         enAttente = false;
+    }
+
+    public synchronized void startRead()   {
+        new Thread(this).start();
+        try {
+            Thread.sleep(1);
+        } catch (InterruptedException e) {}
+    }
+
+    public synchronized void stopRead()   {
+        controleur.stopRead();
+        try {
+            Thread.sleep(1);
+        } catch (InterruptedException e) {}
+    }
+
+    public boolean isWaiting() {
+        return enAttente;
+    }
+
+
+}

lecteursredacteurs/src/main/java/LecteursRedacteursTest.java

@@ -1,6 +1,3 @@
-package ch.heig.pl.lecteursredacteurs;
-
-
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
@@ -51,6 +48,7 @@ public void lecteursRedacteurs() throws InterruptedException {
         redacteur2.startWrite();
         redacteur1.stopWrite();
 
+
         // redacteur 1 libère mais redacteur 2 passe avant lecteur 3
         assertTrue(lecteur3.isWaiting());
         assertFalse(redacteur2.isWaiting());
@@ -59,6 +57,9 @@ public void lecteursRedacteurs() throws InterruptedException {
         // après les redacteurs , lecteur3 est libéré
         assertFalse(lecteur3.isWaiting());
         lecteur3.stopRead();
+
+
+
     }
 
 }