Interuptions et Exceptions

  public static void main(String[] args) {
    Thread.ofPlatform().start(() -> {
      for (var i = 1;; i++) {
        try {
          Thread.sleep(1_000);
          System.out.println("Thread slept " + i + " seconds.");
        } catch (InterruptedException e) {
          // TODO
        }
      }
    });
  }

  public static boolean isPrime(long candidate) {
    if (candidate <= 1) {
      return false;
    }
    for (var i = 2; i <= Math.sqrt(candidate); i++) {
      if (candidate % i == 0) {
        return false;
      }
    }
    return true;
  }

  public static OptionalLong findPrime() {
    var generator = ThreadLocalRandom.current();
    for (;;) {
      var candidate = generator.nextLong();
      if (isPrime(candidate)) {
        return OptionalLong.of(candidate);
      }
    }
  }

  public static void main(String[] args) throws InterruptedException {
    Thread.ofPlatform().start(() -> {
      System.out.println("Found a random prime : " + findPrime().orElseThrow());
    });
  }

Count And Interrupt (à faire à la maison)

On souhaite avoir 4 threads qui affichent chacun leur numéro et un compteur indéfiniment (chaque thread a son propre compteur). Pour éviter de faire chauffer la machine, l'affichage se fera une fois par seconde (en utilisant Thread.sleep()).
De plus, le thread main va lire des entiers sur l'entrée standard et si l'utilisateur entre une valeur correspondant au numéro d'un thread, ce dernier sera arrêté.
Le code pour lire sur l'entrée standard est le suivant :

  System.out.println("enter a thread id:");
  try (var input = new InputStreamReader(System.in);
         var reader = new BufferedReader(input)) {
      String line;
      while ((line = reader.readLine()) != null) {
        var threadId = Integer.parseInt(line);
        ...
      }
    }

Rappel : on utilise Ctrl-D (Ctrl-Z sous Microsoft Windows) pour indiquer au terminal qu'il faut fermer l'entrée standard.

Comment faire pour que le programme se termine si l'on fait un Ctrl-D dans le terminal ?

Le Juste Prix (exam 2017-2018)

"Le Juste Prix", The price is right en anglais, est un jeu télévisé ou plusieurs candidats s'affrontent pour gagner un article (dont le prix n'est pas connu par les candidats). Chaque candidat propose un prix et le candidat qui indique le prix le plus proche du prix réel d'un article gagne cet article.
Dans cet exercice, vous devez implanter la même mécanique de jeu avec un thread simulant un candidat.
Les tests JUnit pour toutes les questions de l'exercice sont dans la classe ThePriceIsRightTest.java.
Attention, les tests sont volontairement simples pour que vous puissiez les lires. Ils peuvent reporter des erreurs sur la console au lieu de reporter les erreurs dans la partie graphique. Donc un test passe s'il est vert et qu'il ne fait pas d'erreur sur la console.

• Le constructeur de la classe ThePriceIsRight est initialisé avec le prix réel de l'article, ainsi que le nombre de candidats.
  Par exemple, si un article vaux 100 et qu'il y a deux threads, on initialise ainsi :

  var thePriceIsRight = new ThePriceIsRight(100, 2);
  

  
  Le nombre de participants doit être un nombre positif strictement supérieur à zéro.
• La méthode propose prend en paramètre un entier qui correspond au prix proposé par un candidat (un thread). Cette méthode bloque tant que tous les candidats n'ont pas soumis leur prix puis elle renvoie true au thread qui a proposé le prix le plus proche et false à tous les autres threads.
• Si plus de threads que le nombre de participants indiqué à la construction exécutent la méthode propose, la proposition de prix des threads supplémentaires ne sera pas prise en compte et la méthode propose renvoie false.
• Si deux participants proposent le même prix et que c'est le prix le plus proche du prix réel, alors le premier participant (le premier thread ayant proposé le prix) est le gagnant.
• Si un thread qui a déjà proposé un prix est interrompu, son prix est retiré des prix pris en compte (comme s'il n'avait pas joué), donc la méthode propose renvoie false.
  De plus, le juste prix est alors immédiatement calculé sur les threads restants (les threads sont donc débloqués même sans avoir atteint le nombre de participants requis).
• Dans le cas où il y avait un seul participant et qu'il est interrompu, aucun thread n'a le juste prix et la méthode propose doit simplement renvoyer false.

Quelques indications :

• Comme il faut pouvoir retirer la proposition du thread interrompu, il va falloir se souvenir de quel thread a voté quoi.
• Posez-vous la question de qui doit faire le calcul (et à quel moment) pour savoir quel est le thread gagnant, c'est à dire, celui qui est le plus proche du prix réel de l'article.
• Être le plus proche du juste prix veut dire avoir la plus petite distance par rapport au prix réel, donc avoir la valeur la plus petite avec la fonction suivante :

  private int distance(int price) {
    return Math.abs(price - realPrice);
  }
  

• Pour le code qui trouve le thread gagnant, si vous aimez jouer avec les Stream, vous pouvez utiliser le collector Collectors.minBy, mais vous pouvez aussi écrire le code à la main, pourvu que ce soit correct.

Écrire le code de la classe ThePriceIsRight.