# TP2 - Système

Elliott LE GUEHENNEC -- Yorick GEOFFRE

## 1. Simulation d'une patisserie

### A.
Le patron lecteur/rédacteur présente le problème plusieurs lecteurs peuvent lire la même donnée, et ne peuvent pas la modifier; alors que les pâtisseries appartiennent au seul client qui les consommera (et donc les modifiera).

### B.
L'exclusion mutuelle se produit lorsqu'un `Client` veut acheter une `Patisserie` alors qu'aucune n'est disponible. Lorsque cela se produit, la `Boulangerie` bloque le thread en attendant qu'un `Patissier` dépose une `Patisserie` dans la boulangerie, débloquant ainsi la demande du client. La `Boulangerie` débloque le thread correspondant et retourne la `Patisserie` désirée au client.

![](../docs/s1.svg)

La `Boulangerie` est donc le moniteur dans ce modèle, on l'utilise pour synchroniser toutes les opérations des `Client`, des `Patissier`, et la file d'attente.

Pour lancer des threads, on a créé une class ThreadWeaver. On peut lui faire passer des `Runnable` avec `addRunners()`, puis on leur assigne un thread chacun avec `weave()`, avant de les lancer avec `run()`. Avec `recover()`, on attend que tous les threads se soient terminés, et avec `termina()`, on interrompt tous les threads restants en affichant une erreur.

Le code de cette classe est en bas de ce document

## Annexes

### Le ThreadWeaver
```java
public class ThreadWeaver {
    private final List<Runnable> runners = new ArrayList<Runnable>();
    private final List<Thread> managed = new ArrayList<Thread>();
    public void addRunners(Runnable... runners){

    }

    public void weave(){
        for(Runnable r: runners){
            managed.add(new Thread(r));
        }
    }

    public void run(){
        for(Thread t : managed){
            t.start();
        }
    }

    public void recover(){
        for(Thread t : managed){
            try {
                t.wait();
            }catch(InterruptedException ie){
                System.out.println(ie.getMessage());
            }
        }
        termina();
    }

    public void recover(Long timeout){
        for(Thread t : managed){
            try {
                t.wait(timeout);
            }catch(InterruptedException ie){
                System.out.println(ie.getMessage());
            }
            managed.remove(t);
        }
        termina();
    }

    public void termina(){
        for(Thread t : managed){
            System.out.println("Thread "+t.getName()+" has not stopped being cleaned up");
            t.interrupt();
        }
        managed.clear();
        runners.clear();
    }
}
```