So verwenden Sie die Java-Multithread-Synchronisierungstoolklasse CyclicBarrier

Was ist CyclicBarrier?

CyclicBarrier ist eine im Java-Parallelitätspaket bereitgestellte Synchronisierungstoolklasse. Sie ermöglicht es mehreren Threads, an einer bestimmten Barriere zu warten, bis alle Threads die Barriere erreichen, bevor sie mit der Ausführung fortfahren. Das Implementierungsprinzip von CyclicBarrier basiert auf ReentrantLock und Condition. Das Warten und Aufwecken von Threads wird durch mehrmaliges Aufrufen der Methodewait () realisiert.

Grundlegende Verwendung von CyclicBarrier

Die grundlegende Verwendung von CyclicBarrier ist sehr einfach. Sie müssen lediglich ein CyclicBarrier-Objekt erstellen und den Zählerwert auf die Anzahl der wartenden Threads festlegen. Rufen Sie nach Abschluss der Ausführung jedes Threads die Methode „await()“ von CyclicBarrier auf, um darauf zu warten, dass die Ausführung anderer Threads abgeschlossen ist. Wenn alle Threads die Barriere erreichen, wird die Barriere geöffnet und alle Threads werden weiter ausgeführt.

Quellcode-Implementierung von CyclicBarrier

Das Implementierungsprinzip von CyclicBarrier basiert auf ReentrantLock und Condition, und das Warten und Aufwecken von Threads wird durch mehrmaliges Aufrufen der Methodewait() erreicht. Die Quellcode-Implementierung von CyclicBarrier besteht hauptsächlich aus zwei Teilen: der Initialisierung der Barriere und dem Warten und Aufwecken der Barriere.

(1) Initialisierung von CyclicBarrier

Beim Erstellen eines CyclicBarrier-Objekts müssen Sie die Anzahl der wartenden Threads und den Ausführungsvorgang der Barriere angeben. Die Konstruktionsmethode des CyclicBarrier-Objekts lautet wie folgt:

public CyclicBarrier(int parties, Runnable barrierAction)

wobei „partys“ die Anzahl der wartenden Threads darstellt und „barriereAction“ die von der Barriere ausgeführte Operation darstellt.

In der Konstruktionsmethode werden ein ReentrantLock-Array in Parteiengröße und ein Condition-Objekt basierend auf der Anzahl der wartenden Threads erstellt. Das ReentrantLock-Array wird verwendet, um sicherzustellen, dass mehrere Threads die Barriere erreichen und gleichzeitig warten können, und das Condition-Objekt wird zum Warten und Aufwecken von Threads verwendet.

(2) Warten und Aufwachen von CyclicBarrier

Wenn der Thread die Methode „await()“ ausführt, versucht er zunächst, die Sperre des ReentrantLock-Objekts zu erhalten. Wenn die Erfassung fehlschlägt, wird der Thread zur Warteschlange hinzugefügt warten, bis die Sperre aufgehoben wird. Nach Erhalt der Sperre ermittelt der Thread, ob der aktuelle Zähler die Anzahl der wartenden Threads erreicht hat. Wenn dies der Fall ist, führt er Barriereoperationen durch und setzt den Zähler auf Parteien zurück, wodurch alle Threads in der Warteschlange aktiviert werden. Wenn der Zähler die Anzahl der wartenden Threads nicht erreicht, wird der Thread zur Warteschlange hinzugefügt, um auf die Ankunft anderer Threads zu warten.

Der Quellcode der waiting()-Methode von CyclicBarrier lautet wie folgt:

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        // 获取锁
        lock.lock();
        // 计数器减1
        int index = --count;
        if (index == 0) {
            // 如果计数器为0，执行屏障操作并唤醒等待队列中的所有线程
            final Runnable command = barrierCommand;
            if (command != null) {
                command.run();
            }
            next
        trip.signalAll();
    } else {
        try {
            // 等待其他线程到达屏障处
            int phase = generation;
            trip.await();
            // 如果是最后一个到达屏障的线程，执行屏障操作并唤醒等待队列中的所有线程
            if (phase == generation) {
                command = barrierCommand;
                if (command != null) {
                    command.run();
                }
            }
            // 计数器重置
            nextGeneration();
        } catch (InterruptedException ie) {
            // 如果线程在等待时被中断，抛出InterruptedException异常
            cancel();
            throw ie;
        } catch (BrokenBarrierException bbe) {
            // 如果屏障被破坏，抛出BrokenBarrierException异常
            broken = true;
            trip = new Condition[parties];
            throw bbe;
        }
    }
    return index;
} finally {
    // 释放锁
    lock.unlock();
}
}

In der waiting()-Methode von CyclicBarrier erhalten Sie zunächst die Sperre des ReentrantLock-Objekts und dekrementieren den Zähler um 1. Wenn der Zähler 0 ist, führen Sie die Barriereoperation aus und aktivieren Sie alle Threads in der Warteschlange. Wenn der Zähler nicht 0 ist, warten Sie, bis andere Threads an der Barriere ankommen.

Wenn der Thread während des Wartevorgangs unterbrochen wird, wird eine InterruptedException ausgelöst. Wenn die Barriere durchbrochen wird, wird eine BrokenBarrierException ausgelöst. Wenn es der letzte Thread ist, der die Barriere erreicht, wird die Barriereoperation ausgeführt und alle Threads in der Warteschlange werden aufgeweckt und der Zähler wird auf Partys zurückgesetzt.

Verwendungsszenarien von CyclicBarrier

CyclicBarrier eignet sich für Szenarien, in denen mehrere Threads darauf warten müssen, dass einander einen bestimmten Barrierepunkt erreicht, bevor sie mit der Ausführung fortfahren. Wenn beispielsweise mehrere Threads eine bestimmte Aufgabe gleichzeitig ausführen müssen, eine bestimmte Aufgabe jedoch auf den Abschluss anderer Aufgaben warten muss, bevor sie fortfahren kann, können Sie CyclicBarrier verwenden, um Thread-Synchronisierung und Zusammenarbeit zu erreichen.

Darüber hinaus kann CyclicBarrier auch zur Implementierung der Pipeline-Verarbeitung verwendet werden. Im Producer-Consumer-Modell können beispielsweise mehrere Producer gleichzeitig Daten zur Warteschlange hinzufügen Der Verbraucher verarbeitet die Daten und fügt dann weitere Daten hinzu.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Java-Multithread-Synchronisierungstoolklasse CyclicBarrier. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!