Merge branch 'master' of https://codefirst.iut.uca.fr/git/elliott.le_guehennec/Eclair

src/Main.java

@@ -8,7 +8,9 @@ public class Main {
         ThreadWeaver tw = new ThreadWeaver();
         Boulangerie b = new Boulangerie();
         Patissier p = new Patissier(b);
-        tw.addRunners(p, new Client(b));
+        Client c1 = new Client(b);
+        Client c2 = new Client(b);
+        tw.addRunners(p, c1, c2);
         tw.weave();
         tw.run();
 

src/Main3A.java

@@ -0,0 +1,21 @@
+import sweet.*;
+import world.ThreadWeaver;
+
+public class Main3A {
+    public static void main(String[] args) {
+        ThreadWeaver tw = new ThreadWeaver();
+        Boulangerie b = new BoulangerieThreadSafe();
+        Patissier p = new Patissier(b);
+        tw.addRunners(p, new LimitedClient(b));
+        tw.weave();
+        tw.run();
+
+        try{
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        p.shouldRun.set(false);
+        tw.recover();
+    }
+}

src/Main3B.java

@@ -0,0 +1,21 @@
+import sweet.*;
+import world.ThreadWeaver;
+
+public class Main3B {
+    public static void main(String[] args) {
+        ThreadWeaver tw = new ThreadWeaver();
+        Boulangerie b = new BoulangerieThreadSafe();
+        Patissier p = new Patissier(b);
+        tw.addRunners(p, new Client(b));
+        tw.weave();
+        tw.run();
+
+        try{
+            Thread.sleep(2000);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+        p.shouldRun.set(false);
+        tw.recover();
+    }
+}

src/sweet/Boulangerie.java

@@ -7,30 +7,23 @@ import java.util.*;
 public class Boulangerie {
     private final ArrayList<Patisserie> sweets = new ArrayList<>();
 
-    /**
+    public synchronized boolean depose(Patisserie p) {
-     * 
-     */
-    public synchronized void depose(Patisserie p) {
         this.notify();
         sweets.add(p);
+        return true;
     }
 
-    /**
+
-     * 
-     */
     public synchronized Patisserie achete() {
-        while(sweets.size() == 0) {
+        while(getStock() == 0) {
             try {this.wait();} catch (InterruptedException ignored) {}}
             Patisserie pat = sweets.get(0);
             sweets.remove(pat);
             return pat;
     }
 
-    /**
+    public int getStock(){
-     * 
+        return sweets.size();
-     */
-    public void getStock() {
-        // TODO implement here
     }
 
 }

src/sweet/BoulangerieThreadSafe.java

@@ -7,23 +7,25 @@ import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.TimeUnit;
 
 public class BoulangerieThreadSafe extends Boulangerie{
-    private final BlockingQueue<Patisserie> sweets = new ArrayBlockingQueue<Patisserie>(50);
+    private final BlockingQueue<Patisserie> sweets = new ArrayBlockingQueue<Patisserie>(10);
 
     @Override
-    public void depose(Patisserie p) {
+    public boolean depose(Patisserie p) {
         try{
+            if(sweets.remainingCapacity() <= 0) return false;
             sweets.put(p);
-        }catch(InterruptedException ignored){}
+        }catch(InterruptedException ignored){return false;}
+        return true;
     }
 
     @Override
     public Patisserie achete() {
-        try{return sweets.take();} catch (InterruptedException e) {}
+        try{return sweets.take();} catch (InterruptedException ignored) {}
         return null;
     }
 
     @Override
-    public void getStock() {
+    public int getStock() {
-        // TODO implement here
+        return sweets.size();
     }
 }

src/sweet/Client.java

@@ -15,8 +15,8 @@ public class Client implements Runnable {
 
     @Override
     public void run() {
-        while(true) {
+        while(local.getStock() < 9999) {
-            local.achete();
+            if(local.achete() == Gateau.GATEAU_EMPOISONNE) break;
             System.out.println("J'ai acheté ma patisserie");
             try {
                 Thread.sleep(80);

src/sweet/Gateau.java

@@ -8,7 +8,7 @@ import java.util.*;
  * 
  */
 public class Gateau extends Patisserie {
-
+    public static final Gateau GATEAU_EMPOISONNE = new Gateau();
     /**
      * Default constructor
      */

src/sweet/LimitedClient.java

@@ -1,6 +1,7 @@
 package sweet;
 
 public class LimitedClient extends Client{
+    private int consumed = 0;
     public LimitedClient(Boulangerie b) {
         super(b);
     }
@@ -9,6 +10,8 @@ public class LimitedClient extends Client{
     public void run() {
         while(true) {
             local.achete();
+            consumed++;
+            if(consumed > 10) break;
             System.out.println("J'ai acheté ma patisserie - Limited");
             try {
                 Thread.sleep(80);

src/sweet/Patissier.java

@@ -9,7 +9,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
  */
 public class Patissier implements Runnable {
     public AtomicBoolean shouldRun = new AtomicBoolean(true);
-    private final Boulangerie local;
+    protected final Boulangerie local;
     /**
      * Default constructor
      */
@@ -20,7 +20,9 @@ public class Patissier implements Runnable {
     @Override
     public void run() {
         while(shouldRun.get()) {
-            local.depose(new Patisserie());
+            if(!local.depose(new Patisserie())){
+                shouldRun.set(false);
+            }
             System.out.println("J'ai produit ma patisserie");
             try {
                 Thread.sleep(100);

src/sweet/PatissierSuicidal.java

@@ -0,0 +1,31 @@
+package sweet;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * 
+ */
+public class PatissierSuicidal extends Patissier {
+    public AtomicBoolean shouldRun = new AtomicBoolean(true);
+    /**
+     * Default constructor
+     */
+    public PatissierSuicidal(Boulangerie b) {
+        super(b);
+    }
+
+    @Override
+    public void run() {
+        while(shouldRun.get()) {
+            if(!local.depose(new Patisserie())){
+                shouldRun.set(false);
+            }
+            System.out.println("J'ai produit ma patisserie");
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                break;
+            }
+        }
+    }
+}