Concurrence Coopérative

Exercice 1 - Scheduler Fifo

1. Qu'est ce que la concurrence coopérative ?
   Qu'elle sont ses avantages et ses inconvénients ?
2. On souhaite implanter l'interface Scheduler (et sa classe compagnon SchedulerImpl), mais avant il faut comprendre ce que font les différentes méthodes. Pour cela ajouter les commentaires de documentation pour chacune des méthodes.
3. Avant d'écrire la classe FifoScheduler qui implante l'interface scheduler et "schedule" les continuations dans l'ordre first in first out, écrivez un main de test avec deux continuations qui chacune font un yield.
4. Ecrire le code de la classe FifoScheduler et vérifier que le main fonctionne correctement.

Exercice 2 - Barrier

1. Rappeler ce qu'est une barrière et son mode de fonctionnement (comme CyclicBarrier ou CountDownLatch).
2. Implanter la classe Barrier et sa méthode await et tester en écrivant un main qui utilise le scheduler FifoScheduler.

Exercice 3 - Scheduler Random

1. Recopier le main de la Barrier qui servira de test pour le scheduler.
2. Implanter le scheduler RandomScheduler qui choisi la prochaine continuation à exécuter de façon aléatoire.
   Vous utiliserez java.util.ThreadLocalRandom comme générateur pseudo aléatoire.
3. Le code de la Barrier garantie t'il que à la sortie de la Barrier n'importe qu'elle Continuation va s'exécuter ?
   Si ce n'est pas le cas, modifier le code de la Barrier.

Exercice 4 - Lock

  public static void main(String[] args) {
    var scheduler = new RandomScheduler();
    var lock = new Lock(scheduler);
    var shared = new Object() {
      int x;
      int y;
    };

    IntStream.range(0, 2).forEach(id -> {
      scheduler.schedule(() -> {
        for (;;) {
          lock.lock();
          try {
            shared.x = id;
            //scheduler.pause();
            shared.y = id;
          } finally {
            lock.unlock();
          }
          //scheduler.pause();
        }
      });
    });
    scheduler.schedule(() -> {
      for (;;) {
        lock.lock();
        try {
          System.out.println(shared.x + " " + shared.y);
        } finally {
          lock.unlock();
        }
        //scheduler.pause();
      }
    });

    scheduler.loop();
  }
    

1. En utilisant le main de test ci-dessus, écrire la classe Lock et ses méthodes lock et unlock sans se soucier de la ré-entrance
2. Modifier votre implantation pour quelle soit ré-entrante et modifier le main pour tester la ré-entrance.

Exercice 5 - Exchanger

  public static void main(String[] args) {
    var scheduler = new FifoScheduler();
    var exchanger = new Exchanger<String>(scheduler);
    scheduler.schedule(() -> {
      System.out.println("cont1: " + exchanger.exchange("hello"));
    });
    scheduler.schedule(() -> {
      System.out.println("cont2: " + exchanger.exchange("hi"));
    });
    scheduler.loop();
  }
   

• Rappeler le fonctionnement d'un Exchanger.
• Sachant que l'on ne veut pas que l'on puisse utiliser l'exchanger avec plus que deux threads, proposer un code pour la classe Exchanger tel que le main ci dessus fonctionne.

Exercice 6 - Fibers

• Quel est la différénce entre une fiber et un thread ?
• En allant regarder l'API des fibers, quel est la code qui permet de créer deux fibers se partageant un même exécuteur configurer pour utiliser une seul thread.
• Modifier le code TCPThreadProxy pour utiliser des fibers plutôt que des threads.