Erstellen einer gleichzeitigen Liste in Java

1. Treiberklasse in Java
2. Thread-Klasse in Java
3. Verwendung von die Methode run in Java

Parallelität ist der Prozess, um Programme oder Funktionen parallel auszuführen. Wenn mehrere Threads mit derselben Methode arbeiten, ermöglicht dies eine verkürzte Zeit und einen erhöhten Durchsatz.

Java bietet die Klasse CopyOnWriteArrayList, die eine effiziente Art von List-Operationen ermöglicht und die Funktionen threadsicher arbeiten. Das bedeutet, dass, wenn zwei oder mehr Threads versuchen, die Liste zu manipulieren, die angegebene Klasse Thread-sichere Lese-Schreib-Operationen zulässt. Intern wird beim Modifizieren von Methoden der Listenschnittstelle wie den Funktionen add oder remove der Inhalt der CopyOnWriteArrayList in die neue interne Kopie kopiert. Diese Funktion macht es Thread-sicher und ermöglicht die parallele Verarbeitung.

Die Klasse CopyOnWriteArrayList ist im Paket java.util.concurrent vorhanden. Unten finden Sie ein Codeblockbeispiel, das die Operationen für die angegebene Klasse demonstriert.

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);
    }
  }
}

Treiberklasse in Java

Im obigen Programm sind drei Klassen definiert. Die erste mit der Methode main ist die Treiberklasse, andere sind zum Funktionieren da. In der Klasse ConcurrentListOperations wird die temporäre Liste zunächst mit drei ganzen Zahlen initialisiert. Die gebildete temp_list wird an den CopyOnWriteArrayList-Konstruktor übergeben, der eine andere Art von ArrayList-Klasse ist.

Die Klasse initialisiert das Array mit den oben definierten Werten. Nun wird die Instanz von copyOnWriteArrayList an die zuvor erstellten Thread-Klassen übergeben. Diese Klasse macht die Liste nur threadsicher; Daher werden parallele Operationen auf der Listeninstanz ermöglicht.

Thread-Klasse in Java

Die beiden Thread-Klassen sind ReadThread und WriteThread. Die eigentliche Arbeit der Klasse besteht darin, dieselbe Liste gleichzeitig zu lesen und zu schreiben. Die Klasse WriteThread erweitert die Klasse Thread, die eine Möglichkeit darstellt, Threads zu deklarieren. Es verfügt über einen öffentlichen Konstruktor, der die empfangene Listeninstanz der lokalen Variablen zuweist und den Threadnamen initialisiert.

Die eigentliche Geschäftslogik für Threads liegt in ihrer Methode run vor. Um einen Thread zu starten, wird die Methode start über die neu erstellte Thread-Klasseninstanz aufgerufen.

Verwendung von die Methode run in Java

In der Methode run der Klasse WriteThread wird in der Schleifenbedingung ein Zähler initialisiert, um die Iterationen der Klasse write in der Methode run zu verfolgen. Die do-while-Schleife wird verwendet, um die Anzahl der Iterationsläufe zu verfolgen.

Innerhalb des Bedingungsblocks wird die Methode sleep der Klasse Thread aufgerufen, um den Thread für die definierte Zeit in den Ruhezustand zu versetzen. Die Funktion bewirkt, dass der parallel ausgeführte Thread für eine bestimmte Anzahl von Millisekunden in den Ruhezustand versetzt wird. Es wirft IllegalArgumentException, wenn die übergebenen Millisekunden negativ sind und InterruptedException, wenn ein Thread unterbrochen wird.

Die Methode add wird verwendet, um Elemente in der Liste durch gleichzeitige Threads hinzuzufügen. Es wirft UnsupportedOperationException, wenn die Operation von der Listeninstanz nicht zugelassen wird. Andererseits wirft es ClassCastException, wenn die Klasse des angegebenen Elements nicht vom gleichen Typ der Liste ist. Es wirft NullPointerException, wenn der angegebene Wert null ist, und IllegalArgumentException, wenn eine Eigenschaft dieses Elements das Hinzufügen des Elements verhindert.

Ebenso wird in der Methode run der Klasse ReadThread ein Konstruktor definiert; es initialisiert den Namen und die Liste. Die Methode run hat die eigentliche read-Logik. Die Klasse StringBuilder wird verwendet, um Manipulationen in der Ausgabe vorzunehmen. Die Methode append hängt die in der Write-Thread-Klasse gefundene Ausgabe an die vorhandene an.

Daher laufen die Operationen Lesen und Schreiben gleichzeitig ab und werden in der Konsole im obigen Format gedruckt. Der Write-Thread schläft für etwa 5000 Millisekunden, und die Writer-Ausgabe wird im Vergleich zum read-Thread seltener angezeigt. Das ... bedeutet, dass die Threads endlos laufen und dieselbe Ausgabe ausgeben, weil keine Schreib-Operation durchgeführt wurde. Ist der write-Prozess erfolgreich, druckt der read-Thread nun den neu hinzugefügten Wert.

Ausgabe:

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