Java CyclicBarrier await() method

The await() method of the Java CyclicBarrier class is used to make the current thread waiting until all the parties have invoked await() method on this barrier or the specified waiting time elapses.

Syntax

This method is overloaded in the following ways.

public int await() throws InterruptedException,BrokenBarrierException
public int await(long timeout, TimeUnit unit) throws InterruptedException,BrokenBarrierException,TimeoutException

Parameters

timeout ? the time to wait for the barrier

unit ? the time unit of the timeout parameter

Return

The arrival index of the current thread.

Example 1

import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
class Computation1 implements Runnable
{
    public static int product = 0;
    public void run()
    {
        product = 2 * 3;
        try
        {
            CyclicBarrierAwaitExample1.newBarrier.await();
        } 
        catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        }
    }
}
class Computation2 implements Runnable
{
    public static int sum = 0;
    public void run()
    {
        // check if newBarrier is broken or not
        System.out.println("Is the barrier broken? - " + CyclicBarrierAwaitExample1.newBarrier.isBroken());
        sum = 10 + 20;
        try
        {
            CyclicBarrierAwaitExample1.newBarrier.await(3000, TimeUnit.MILLISECONDS);
             // number of parties waiting at the barrier
            System.out.println("Number of parties waiting at the barrier "+
            "at this point = " + CyclicBarrierAwaitExample1.newBarrier.getNumberWaiting());
        } catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        } 
        catch (TimeoutException e) 
        {
            e.printStackTrace();
        }
    }
}
public class CyclicBarrierAwaitExample1 implements Runnable
{
    public static CyclicBarrier newBarrier = new CyclicBarrier(3);
    public static void main(String[] args)
    {
        // parent thread
        CyclicBarrierAwaitExample1 test = new CyclicBarrierAwaitExample1();
        Thread t1 = new Thread(test);
        t1.start();
    }
    @Override
    public void run()
    { 
        System.out.println("Number of parties required to trip the barrier = "+
        newBarrier.getParties());
        System.out.println("Sum of product and sum = " + (Computation1.product + 
        Computation2.sum));
         
        // objects on which the child thread has to run
        Computation1 comp1 = new Computation1();
        Computation2 comp2 = new Computation2();
         
        // creation of child thread
        Thread t1 = new Thread(comp1);
        Thread t2 = new Thread(comp2);
         
        // moving child thread to runnable state
        t1.start();
        t2.start();
        try
        {
            CyclicBarrierAwaitExample1.newBarrier.await();
        } 
        catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        }
         // barrier breaks as the number of thread waiting for the barrier
        // at this point = 3
        System.out.println("Sum of product and sum = " + (Computation1.product + 
        Computation2.sum));
        // Resetting the newBarrier
        newBarrier.reset();
        System.out.println("Barrier reset successful");
    }
}

Test it Now

Output:

Number of parties required to trip the barrier = 3
Sum of product and sum = 0
Is the barrier broken? - false
Number of parties waiting at the barrier at this point = 0
Sum of product and sum = 36
Barrier reset successful

Example 2

import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier; 
class Computation1 implements Runnable
{
    public static int product = 0;
    public void run()
    {
        product = 2 * 3;
        try
        {
            CyclicBarrierAwaitExample2.newBarrier.await();
        } 
        catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        }
    }
}
class Computation2 implements Runnable
{
    public static int sum = 0;
    public void run()
    {
        // check if newBarrier is broken or not
        System.out.println("Is the barrier broken? - " + CyclicBarrierAwaitExample2.newBarrier.isBroken());
        sum = 10 + 20;
        try
        {
            CyclicBarrierAwaitExample2.newBarrier.await(3000, TimeUnit.MILLISECONDS);
            // number of parties waiting at the barrier
            System.out.println("Number of parties waiting at the barrier "+
            "at this point = " + CyclicBarrierAwaitExample2.newBarrier.getNumberWaiting());
        } 
        catch (InterruptedException | BrokenBarrierException e) 
        {
            e.printStackTrace();
        } 
        catch (TimeoutException e) 
        {
            e.printStackTrace();
        }
    }
}
 public class CyclicBarrierAwaitExample2 implements Runnable
{
    public static CyclicBarrier newBarrier = new CyclicBarrier(3);
    public static void main(String[] args)
    {
        // parent thread
        CyclicBarrierAwaitExample2 test = new CyclicBarrierAwaitExample2();
       Thread t1 = new Thread(test);
        t1.start();
    }
    @Override
    public void run()
    {
        System.out.println("Number of parties required to trip the barrier = "+
        newBarrier.getParties());
        System.out.println("Sum of product and sum = " + (Computation1.product + 
        Computation2.sum));
        // objects on which the child thread has to run
        Computation1 comp1 = new Computation1();
        Computation2 comp2 = new Computation2();
        // creation of child thread
        Thread t1 = new Thread(comp1);
        Thread t2 = new Thread(comp2);
        // moving child thread to runnable state
        t1.start();
        t2.start();
         TimeUnit unit = TimeUnit.SECONDS;
        try
        {
            CyclicBarrierAwaitExample2.newBarrier.await(1,unit);
        } 
        catch (InterruptedException | BrokenBarrierException | TimeoutException e) 
        {
            e.printStackTrace();
        }
         // barrier breaks as the number of thread waiting for the barrier
        // at this point = 3
        System.out.println("Sum of product and sum = " + (Computation1.product + 
        Computation2.sum));
       // Resetting the newBarrier
        newBarrier.reset();
        System.out.println("Barrier reset successful");
    }
}

Test it Now

Output:

Number of parties required to trip the barrier = 3
Sum of product and sum = 0
Is the barrier broken? - false
Number of parties waiting at the barrier at this point = 0
Sum of product and sum = 36
Barrier reset successful

Next Topicjava CyclicBarrier

← prev next →