So definieren Sie den Java CountDownLatch-Zähler und die CyclicBarrier-Zyklusbarriere

Definition

CountDownLatch: Eine Synchronisierungshilfe, die es einem oder mehreren Threads ermöglicht, zu warten, bis eine Reihe von Vorgängen, die in anderen Threads ausgeführt werden, abgeschlossen ist.

CyclicBarrier: Eine Synchronisationshilfe, die es einer Reihe von Threads ermöglicht, darauf zu warten, dass einander einen gemeinsamen Barrierenpunkt erreichen.

Das Obige ist die offizielle Definition von Oracle. Einfach ausgedrückt:

CountDownLatch: Zähler, der es einem oder mehreren Threads ermöglicht, zu warten, bis eine Reihe von in anderen Threads ausgeführten Vorgängen abgeschlossen ist.

CyclicBarrier: Zyklische Barriere, die es einer Gruppe von Threads ermöglicht, darauf zu warten, dass einander einen gemeinsamen Barrierenpunkt erreicht.

DIFFERENCE

• CountDownLatch ist Mitglied von AQS (AbstractQueuedSynchronizer), CyclicBarrier jedoch nicht.

• Im Verwendungsszenario von CountDownLatch gibt es zwei Arten von Threads: einer ist der wartende Thread, der die Methode „await()“ aufruft, und der andere ist die Operation, die ausgeführt wird ruft die countDownl()-Methode auf. Im Kontext von CyclicBarrier sind alle Threads Threads, die aufeinander warten und vom gleichen Typ sind.

• CountDownLatch ist ein Abwärtszähler und kann nach dem Dekrementieren nicht zurückgesetzt werden und wird nach dem Inkrementieren automatisch zurückgesetzt.

#🎜 🎜## 🎜🎜#CountDownLatch-Beispiel

Erstellen Sie zwei Gruppen von Threads. Eine Gruppe wartet, bis die Ausführung der anderen Gruppe abgeschlossen ist, bevor sie fortfährt

CountDownLatch countDownLatch = new CountDownLatch(5);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < 5; i++) {
    executorService.execute(() -> {
        countDownLatch.countDown();
        System.out.println("run..");
    });
}
for (int i = 0; i < 3; i++) {  //我们要等上面执行完成才继续
    executorService.execute(() -> {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("await..");
    });
}
executorService.shutdown();

Drucken:

# 🎜🎜##🎜 🎜#run..

run..

run..

run..

run..
await..
await ..#🎜🎜 #await..


Warten Sie, bis die Ausführung des Akkumulationsthreads abgeschlossen ist, und dann gibt der Hauptthread das Akkumulationsergebnis aus

public class ThreadUnsafeExample {
    private int cnt = 0;
    public void add() {
        cnt++;
    }
    public int get() {
        return cnt;
    }
    public static void main(String[] args) throws InterruptedException {
        final int threadSize = 1000;
        ThreadUnsafeExample example = new ThreadUnsafeExample();
        final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < threadSize; i++) {
            executorService.execute(() -> {
                example.add();
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println(example.get());
    }
}

Drucken:

#🎜🎜 #997

3 Parallelität simulieren

ExecutorService executorService = Executors.newCachedThreadPool();
        CountDownLatch countDownLatch = new CountDownLatch(1);
        for (int i = 0; i < 5; i++) {
            executorService.submit( () -> {
                try {
                    countDownLatch.await();
                    System.out.println("【" + Thread.currentThread().getName() + "】开始执行……");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            });
        }
        Thread.sleep(2000);
        countDownLatch.countDown();//开始并发
        executorService.shutdown();

Drucken:

#🎜 🎜 #【pool-2-thread-2】Ausführung starten...

【pool-2-thread-5】Ausführung starten... 2-thread-1】Ausführung starten... 🎜🎜#Alle Threads warten füreinander, bis ein bestimmter Schritt abgeschlossen ist, bevor die Ausführung fortgesetzt wird

        final int totalThread = 3;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < totalThread; i++) {
            executorService.execute(() -> {
                System.out.println("before..");
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException | BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("after..");
            });
        }
        executorService.shutdown();

Drucken:

before..

before..# 🎜🎜#before ..
nach..
nach..
nach..

Das obige ist der detaillierte Inhalt vonSo definieren Sie den Java CountDownLatch-Zähler und die CyclicBarrier-Zyklusbarriere. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!