Examen de concurrence sur table

Exercice 1 - Questions de cours (7)

1. Pourquoi est-il important de savoir si une classe est thread-safe où non.
2. Pourquoi dit-on que déclarer une méthode synchronized n'est pas une bonne idée. Quelle est le problème ?
3. Expliquer dans quel cas une exception InterruptedException peut être levée lors d'un appel à la méthode put de l'interface BlockingQueue ?
4. Pourquoi Java demande à ce que l'appel de la méthode foo.notify() soit fait dans un bloc synchronized sur foo ?
5. Le code suivant à un problème de publication. Expliquer où est le problème et ce qui va se passer si le problème de publication arrive

           class Hello {
             private List<String> list;
             
             public Hello(List<String> list) {
               this.list = list;
             }
             
             public int size() {
               return list.size();
             }
           }
         

6. Quelle(s) sont la ou les différente(s) séquence(s) de valeurs possibles affichées par le code suivant

           class Foo {
             final int value;
             Foo(int value) {
               this.value = value;
               new Thread(() -> {
                 System.out.println(value);
               }).start();
             }
             public static void main(String[] args) {
               int val = 13;
               new Foo(17);
               System.out.println(val);
             }
           }
         

Exercice 2 - Execution (5)

1. Rappeler quel est l'intérêt des executeurs par rapport à créer des threads à la main.
2. Comment fonctionne la méthode shutdown ?
3. Ecrire en utilisant un executeur possèdant un pool de 4 threads, le calcul les valeurs de la fonction sin pour les valeurs de 0 à 10 sachant que chaque calcul d'une valeur de la fonction doit se faire dans une tâche et que l'affichage des résultats doit être fait par la thread main.
4. Pourquoi cette exemple est un très mauvais exemple d'utilisation des exécuteurs ?

Exercice 3 - Benne à gravat (8)

import java.util.ArrayList;
import java.util.List;

public class Dumpster {
  private final int capacity;
  private final ArrayList<String> rubbles = new ArrayList<>();

  public Dumpster(int capacity) {
    this.capacity = capacity;
  }
  
  public void addRubble(String rubble) {
    if (rubbles.size() == capacity) {
        throw new IllegalStateException();
    }
    rubbles.add(rubble);
  }
  
  public void emptyIntoTruck(List<? super String> truck) {
    truck.addAll(rubbles);
    rubbles.clear();
  }
}
   

1. Expliquer pourquoi le code de la classe Dumpster ci-dessus n'est pas thread safe en utilisant un exemple.
2. Modifier le code de la classe pour la rendre thread-safe (sans utiliser de classe du package java.util.concurrent ni de ses sous packages).
3. Modifier le code de la classe pour la rendre thread-safe en utilisant les verrous du package java.util.concurrent.locks.
4. Modifier le code de la classe pour la rendre thread-safe avec une implantation lock-free en utilisant les opérations atomiques.
   Note: pour addRubble, l'idée est de re-créer une nouvelle liste.
5. Ecrire un code créant 7 threads ajoutant chacune un type de gravat (rubble0 pour la première thread, rubble1 pour la seconde, etc) toute les 30 ms dans la benne et une autre thread qui toutes les 120 ms va vider la benne (la liste correspondant au camion sera créé et oublié après chaque appel).
6. Expliquer quel doit être la capacity minimum pour ne pas avoir d'exception avec le scénario décrit à la question précédente.
   Expliquer pourquoi si l'on veut s'adapter à tous les scénarios possibles la seule solution consiste à arréter les threads si il n'y a plus de place dans la benne.
7. Modifier le code que vous avez proposé comme première implantation (la réponse à la question 2), pour éviter la levé de l'exception si la benne est pleine.