:: Enseignements :: ESIPE :: E4INFO :: 2012-2013 :: Java Réseau I - Concurrence et E/S ::

Examen de concurrence sur table

Exercice 1 - Questions de cours (6)

Réponder aux questions suivantes en deux ou trois phrases, pas plus.

Expliquer ce que veut dire qu'une classe est thread-safe ?
Qu'est ce qu'une attente active/passive ?
Quelle type d'attente ne doit pas apparaitre dans un programme ?

Expliquer pourquoi la classe n'est pas thread safe.
Modifier la classe pour qu'elle soit thread safe.

        class StringList {
          ArrayList<String> list = new ArrayList<>();
          
          public void add(String element) {
            list.add(element);
          }
        }

Qu'est ce qu'un ForkJoinPool et à quoi sert il ?

Pourquoi le code suivant n'est pas thread-safe ?
Que faut-il utiliser à la place ?

        if (!lock.isLocked()) {
          lock.lock();
          ...
        }

Pourquoi Java demande à ce que l'appel de la méthode foo.notify() soit fait dans un bloc synchronized sur foo ?
A quoi sert la classe ThreadLocal ?

La classe ci-dessous a t elle des problèmes de publication ?
Si oui pourquoi ? Si non pourquoi ?

      class Foo {             
        int a;
        volatile int b;
        final int c;                   
    
        Foo(int a, int b, int c) { 
          this.a = a;       
          this.b = b;
          this.c = c;       
        }                  
      }

Exercice 2 - Lock Free Point

Lors du TD2, vous avez vu comment rendre la classe Point ci-dessous thread-safe en utilisant le mécanisme de section critique en utilisant des locks et autres verrous.
Ecrire une version lock-free en utilisant les opérations atomiques.

  public class Point {
    private int x;
    private int y;

    public void move(int x, int y) {
      this.x = x;
      this.y = y;
    }

    @Override
    public String toString() {
      return "(" + x + ',' + y + ')';
    }

    public static void main(String[] args) {
      final Point p=new Point();

      for(int i = 0; i<2; i++) {
        final int id = i;
        new Thread(new Runnable() {
          public void run() {
            for(;;) {
              p.move(id, id);
              System.out.println(p);
            }
          }
        }).start();
      }
    }
  }

Note: le main que vous ai donné à titre d'exemple et ne doit pas être modifié.

Exercice 3 - Copy Copy

On souhaite écrire le code d'une méthode copy2 qui prend en paramètre 3 FileChannel déjà ouverts. Le premier sera utilisé en lecture et copiera ses données dans les deux autres FileChannel ouverts en écriture.
La méthode copy2 est donc déclarée de la façon suivante

      void copy2(FileChannel in, FileChannel out1, FileChannel out2)
          throws IOException

Si il est impossible de lire ou d'écrire dans un FileChannel, la méthode lèvera directement l'exception IOException.

Fournir un code pour la méthode copy2 en sachant que la lecture en utilisant FileChannel.read est bloquante tant que le système n'a pas lu au moins un octet et que l'écriture par FileChannel.write garantit d'écrire toutes les données.

Exercice 4 - PriorityBarrier

Le but de cet exercice est d'écrire une barrière bloquante qui arrête par sa méthode await(int) un nombre prédéfinie de threads indiqué lors de la construction d'un objet PriorityBarrier et qui reveille celles-ci dans l'ordre de leur priorité, l'ordre étant indiqué lors de l'appel à la méthode await.
En plus du constructeur, la classe PriorityBarrier possède une unique méthode await(int priority) qui lorsqu'elle est appelée par une thread met celle-ci en attente jusqu'à ce que le nombre spécifié de threads soient misent en attente. Les threads participant à la barrière sont alors reveillées dans l'ordre croissant de leur priorité.
Enfin, si une thread paticipant à la barrière est interrompue, alors toutes les threads participant à la barrière (celle interrompue incluse) lèveront l'exception IllegalStateException alors qu'elles sont en attente dans la méthode await.

Indiquer le code de la PriorityBarrier sans se préoccuper de la gestion du mécanisme d'interruption sachant que vous n'avez pas le droit d'utiliser de collections du package java.util.concurrent.
Indiquer le code qui doit être ajouté (au(x) bon(s) endroit(s)) pour la gestion du mécanisme d'interruption.