Créer une liste concurrente en Java

1. Classe Driver en Java
2. Classe de thread en Java
3. Utiliser la méthode run en Java

La simultanéité est le processus permettant d’exécuter des programmes ou des fonctions dans une exécution parallèle. Lorsque plusieurs threads fonctionnent sur la même méthode, cela permet un temps réduit et un débit accru.

Java fournit la classe CopyOnWriteArrayList qui permet un moyen efficace d’effectuer des opérations List, et les fonctions fonctionnent de manière thread-safe. Cela signifie que lorsque deux threads ou plus tentent de manipuler la liste, la classe donnée autorise les opérations de lecture-écriture d’une manière thread-safe. En interne, lors de la modification des méthodes de l’interface liste telles que les fonctions add ou remove, le contenu de la CopyOnWriteArrayList est copié dans la nouvelle copie interne. Cette fonctionnalité lui permet d’être thread-safe et permet un traitement parallèle.

La classe CopyOnWriteArrayList est présente dans le package java.util.concurrent. Vous trouverez ci-dessous un exemple de bloc de code qui illustre les opérations sur la classe donnée.

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

public class ConcurrentListOperations {
  public static void main(String[] args) {
    List<Integer> temp_list = Arrays.asList(1, 2, 3);
    List<Integer> list = new CopyOnWriteArrayList<>(temp_list);
    new WriteThread("Writer", list).start();
    new ReadThread("Reader", list).start();
  }
}

class WriteThread extends Thread {
  private final List<Integer> list;
  public WriteThread(String name, List<Integer> list) {
    this.list = list;
    super.setName(name);
  }

  public void run() {
    int count = 4;
    int counter = 0;
    do {
      try {
        Thread.sleep(5000);
      } catch (InterruptedException ex) {
        ex.printStackTrace();
      }
      list.add(count++);
      System.out.println(super.getName() + " done");
      counter++;
    } while (counter != 5);
  }
}

class ReadThread extends Thread {
  private final List<Integer> list;
  public ReadThread(String name, List<Integer> list) {
    this.list = list;
    super.setName(name);
  }

  public void run() {
    while (true) {
      StringBuilder output = new StringBuilder("\n" + super.getName() + ":");
      for (Integer nextVal : list) {
        output.append(" ").append(nextVal);
      }
      System.out.println(output);
    }
  }
}

Classe Driver en Java

Dans le programme ci-dessus, trois classes sont définies. La première avec la méthode main est la classe driver, et d’autres sont là pour fonctionner. Dans la classe ConcurrentListOperations, la liste temporaire est initialisée avec trois entiers initialement. La temp_list formée est passée au constructeur CopyOnWriteArrayList, qui est un autre type de classe ArrayList.

La classe initialise le tableau avec les valeurs définies ci-dessus. Maintenant, l’instance de copyOnWriteArrayList est transmise aux classes de threads créées précédemment. Cette classe ne fera que rendre la liste thread-safe ; par conséquent, permettant des opérations parallèles sur l’instance de liste.

Classe de thread en Java

Les deux classes de threads sont ReadThread et WriteThread. Le travail réel de la classe est de lire et d’écrire la même liste simultanément. La classe WriteThread étend la classe Thread, qui est une façon de déclarer les threads. Il a un constructeur public qui affecte l’instance de liste reçue à la variable locale et initialise le nom du thread.

La logique métier réelle des threads est présente dans leur méthode run. Pour démarrer un thread, la méthode start est appelée sur l’instance de classe de thread qui vient d’être créée.

Utiliser la méthode run en Java

Dans la méthode run de la classe WriteThread, un compteur est initialisé dans la condition de boucle pour suivre les itérations de la classe write dans la méthode run. La boucle do-while est utilisée pour garder une trace du nombre d’itérations.

À l’intérieur du bloc conditionnel, la méthode sleep de la classe Thread est appelée pour faire dormir le thread pendant le temps défini. La fonction provoque le parallèle, exécutant le thread en veille pendant un certain nombre de millisecondes. Il lève IllegalArgumentException si les millisecondes passées sont négatives et InterruptedException si un thread est interrompu.

La méthode add permet d’ajouter des éléments dans la liste par threads concurrents. Il lève UnsupportedOperationException si l’opération n’est pas autorisée par l’instance de liste. En revanche, il lève ClassCastException si la classe de l’élément spécifié n’est pas du même type que la liste. Il lève NullPointerException si la valeur spécifiée est null et IllegalArgumentException si une propriété de cet élément empêche l’ajout de l’élément.

De même, dans la méthode run de la classe ReadThread, un constructeur est défini ; il initialise le nom et la liste. La méthode run a la véritable logique read. La classe StringBuilder s’habitue à faire des manipulations dans la sortie. La méthode append ajoute la sortie trouvée dans la classe du thread d’écriture avec celle existante.

Par conséquent, les opérations read et write se produisent simultanément et sont imprimées dans la console dans le format ci-dessus. Le thread d’écriture dort environ 5000 millisecondes et la sortie de l’écrivain s’affichera moins de fois par rapport au thread de read. Le ... signifie que les threads s’exécutent sans fin et impriment la même sortie car aucune opération write ​​n’a été effectuée. Une fois le processus write réussi, le fil read ​​imprime maintenant la nouvelle valeur ajoutée.

Production:

Reader: 1 2 3 
..
Writer done
Reader: 1 2 3 4
...
Writer done
Reader: 1 2 3 4 5