Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

CyclicBarrier — cyklická synchronizácia vlákien

CyclicBarrier synchronizuje pevný počet účastníkov na hraniciach po sebe nasledujúcich fáz. Volanie await() čaká na ostatných; voliteľná akcia spojí výsledky pred začiatkom ďalšej fázy.

Verzia: Java SE 21; repository runtime, production runtime not attested

Syntax

new CyclicBarrier(int parties)
new CyclicBarrier(int parties, Runnable barrierAction)
int await() throws InterruptedException, BrokenBarrierException
int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException

CyclicBarrier z java.util.concurrent je opakovane použiteľný synchronizačný bod. Na rozdiel od jednorazového CountDownLatch podporuje po sebe nasledujúce cykly. Jej konštruktor vyžaduje parties >= 1.

CyclicBarrier.await() čaká na všetkých účastníkov a vracia index príchodu: posledný účastník dostane 0. Posledné vlákno vykoná voliteľnú akciu pred uvoľnením ostatných. Zápisy pred await() sú viditeľné pre túto akciu a jej operácie sú viditeľné po úspešnom návrate účastníkov.

Prerušenie alebo uplynutie časového limitu bariéru preruší: dotknutý účastník dostane InterruptedException alebo TimeoutException, zatiaľ čo ostatní čakajúci účastníci zvyčajne dostanú BrokenBarrierException. Aj reset() preruší čakanie; obnovenie vyžaduje koordináciu. Zabezpečte, aby sa mohli spustiť všetci účastníci, a predíďte tak neobmedzenému čakaniu.

Príklad používa dve vlákna a dva cykly. Každé vlákno zapisuje do vlastného prvku poľa; akcia vypíše súčet. Rozsah: Java SE 21; produkčné behové prostredie nebolo potvrdené.

Príklady

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class BarrierDemo {
    public static void main(String[] args) throws InterruptedException {
        int[] values = new int[2];
        CyclicBarrier barrier = new CyclicBarrier(2,
                () -> System.out.println(values[0] + values[1]));

        Thread[] workers = new Thread[2];
        for (int i = 0; i < workers.length; i++) {
            final int index = i;
            workers[i] = new Thread(() -> {
                try {
                    for (int phase = 1; phase <= 2; phase++) {
                        values[index] = (index + 1) * phase;
                        barrier.await();
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } catch (BrokenBarrierException e) {
                    throw new IllegalStateException(e);
                }
            });
            workers[i].start();
        }
        for (Thread worker : workers) {
            worker.join();
        }
    }
}

Výsledok

3
6

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje