What is a java CyclicBarrier?
CyclicBarrier is a synchronized mechanism that enables a group of Threads to wait for other at a Barrier point. This class in Java works in a synchronized manner and allows the reusability of the program. CyclicBarrier helps in concurrent programming, where different tasks can be carried out in a synchronized pattern. Threads wait for the at a common execution point, and each other threads invokes the await() method. After all, threads reach the barrier, the barrier trips and the system optionally executes a runnable action. Subsequently, it releases all threads to proceed to the next stage of the program.
Key Takeaways
- The concurrent mechanism ensures that multiple threads reach a common barrier point before proceeding to the next task.
- Allows barrier reusability. We can reset them for multiple synchronizations.
- Multiple threads can be synchronized to complete different phases of the task.
- Set timeout to handle indefinite waiting time.
Table of Contents
- What is a java CyclicBarrier
- Components of CyclicBarrier
- How Does CyclicBarrier Work
- Implementing CyclicBarrier
- Real-World Use Cases
- Advanced Features
- When to use CyclicBarrier in Java Program
- Comparison with Other Synchronization Mechanisms
- Common Pitfalls and Troubleshooting
- Reusing CyclicBarrier
Components of CyclicBarrier
Components used in CyclicBarrier for seamless synchronization:
1. Parties
Parties state the thread count that will invoke the ‘await ()’ method. It takes an integer value to initialize the thread count that will synchronize at a common execution point.
int parties = 5;
CyclicBarrier cycbarr = new CyclicBarrier(parties);2. Barrier Action
Barrier action defines the action that will be performed once the thread reaches the barrier point; these get executed before going to another phase after the barrier point.
CyclicBarrier barrier = new CyclicBarrier(parties, new BarrierAction());3. await() Method
The thread invokes the Await() method after reaching the barrier point. These methods indicate that the thread has reached the barrier point and is waiting for the other thread to reach the barrier point before going to another phase.
try {
cycbarr.await();
} catch (InterruptedException exception) {
exception.printStackTrace();
} catch (BrokenBarrierException exception) {
exception.printStackTrace();
}4. reset() Method:
With the reset() method, we can set the barrier to its initial state and also reuse the barrier, if any thread is waiting at the barrier, then this method will throw BrokenBarrierException
cyclicBarrier.reset();How Does CyclicBarrier Work?
CyclicBarrier is a class of java.util.concurrent package. CyclicBarrier works synchronously, and to achieve this, we need to create a new instance of CyclicBarrier by defining the number of parties that will invoke the await() method at the barrier point; these parties will wait for each other before continuing the further execution process. All the parties reach a common execution point and invoke the await() method in a situation called a tripping barrier. Once the barrier trips all parties proceed for further execution process synchronously. We can also define an optional runnable method during initialization, which will perform some action after tripping the barrier, and then CyclicBarrier is rest for the next synchronization cycle. Let us dive into the complete cyclic process with each step
1. Initialization:
The initialization of a CyclicBarrier requires specifying the number of threads that will invoke the ‘await()’ method. It takes an integer value to initialize the thread count that will synchronize at a common execution point.
We can also define the Barrier Action, which will perform certain actions after tripping the barrier. This is an optional argument.
public CyclicBarrier(int parties, Runnable barrierAction)2. Arriving and waiting
Each thread will invoke the await() method and increment the internal count until it reaches the defined integer parties.
These threads will wait for other threads to reach and invoke the await() at the common execution point. CyclicBarrier will keep track of the waiting threads.
try {
cycbarrier.await();
} catch (InterruptedException exception) {
exception.printStackTrace();
}3. Tripping the barrier
Once await() is called by the specific number of threads, the barrier gets tripped and performs the runnable barrier action before going into the next phase.
CyclicBarrier barrier = new CyclicBarrier(parties, () -> {
System.out.println("Tripping of barrier, perform barrier action");
} );
CyclicBarrier barrier = new CyclicBarrier(parties, new BarrierAction());4. Release and reset
All the threads are now released for the next phase, and the CyclicBarrier gets reset for the next synchronization cycle.
cyclicBarrier.reset();Implementing CyclicBarrier
Let us understand Cyclicbarrier by taking an example. Here, we are processing an image with 4 sections, and 4 threads are released to process each section of the image
Code:
import java.util.concurrent.CyclicBarrier;
public class Main {
private static final int PARTIES_NUMBER = 4;
private static final CyclicBarrier cycbarrier = new CyclicBarrier(PARTIES_NUMBER, new BarrierAction ());
public static void main(String args[]) {
Thread P1 = new Thread(new ImageProcessor("Thread no. 1", "Section 1", cycbarrier));
Thread P2 = new Thread(new ImageProcessor("Thread no. 2", "Section 2", cycbarrier));
Thread P3 = new Thread(new ImageProcessor("Thread no. 3", "Section 3", cycbarrier));
Thread P4 = new Thread(new ImageProcessor("Thread no. 4", "Section 4", cycbarrier));
P1.start();
P2.start();
P3.start();
P4.start();
System.out.println("Threads started image processing.\n");
}
}
class ImageProcessor implements Runnable {
private String threadName;
private String section;
private CyclicBarrier barrier;
ImageProcessor(String threadName, String section, CyclicBarrier barrier) {
this.threadName = threadName;
this.section = section;
this.barrier = barrier;
}
//Override
public void run() {
System.out.println(threadName + " is processing image section: " + section + "\n");
try {
Thread.sleep((long) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out
.println(threadName + " has completed the image processing and is Waiting at the barrier for other thread.\n");
try {
barrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class BarrierAction implements Runnable {
//Override
public void run() {
System.out.println("All the threads have completed the image processing section. Start Further processing.");
}
}Output:
Explanation:
Step 1: Initialization
We start by setting up a CyclicBarrier named cycbarrier to synchronize four threads at a common point. This barrier ensures that all threads reach a specific spot before moving forward. We also set up a special action (BarrierAction) to be performed once all threads reach the barrier.
Step 2: Thread Initialization
Four threads (P1, P2, P3, and P4) are created, each assigned to process a different section of an image. All threads share the same CyclicBarrier (cycbarrier) for coordination.
Step 3: Thread Execution
Threads are started to process their respective image sections. A message is printed to indicate that image processing has begun.
Step 4: ImageProcessor Logic
Each thread, represented by the ImageProcessor class, simulates image processing. After completing its section, the thread waits at the barrier for others to catch up before proceeding.
Step 5: BarrierAction
The BarrierAction class defines what happens after all threads reach the barrier. In this case, it prints a message indicating that all threads have completed their image processing sections, and further processing can begin.
Output:
As the threads process their respective image sections, messages are printed. Once all threads reach the barrier, the BarrierAction message signals it’s time for the next processing phase.
Real-World Use Cases
CyclicBarrier in Java is applied in real-world use cases where multiple threads must coordinate and synchronize to perform certain actions after synchronization; this pattern allows concurrent programming and provides an efficient solution. Let’s explore some real-world use cases of CyclicBarrier.
1. Gaming:
CyclicBarrier allows maintaining synchronization between players, where participants wait for other participants before going to the next stage of the game, this allows impartial and consistent experience.
CyclicBarrier is used in Artificial intelligence games to handle multiple aspects of the game synchronously.
2. Data pipeline:
Data processing comprises multiple and parallel phases where CyclicBarrier threads handle the multiple phases and allow parallel processing. CyclicBarrier allows completing one stage and then proceeding to another; this helps maintain data integrity
3. Image Processing:
CyclicBarrier has a valuable use in image processing where an image is distributed in small sections to be processed by different threads, and then all processed sections are merged.
4. Simulation system:
CyclicBarrier has a beneficial use in research and development where vast entities are synchronized at a specific event and later proceed to the next event together; these are important in crucial time events.
Advanced Features
With some advanced features, CyclicBarrier allows for more flexible and concurrent programming:
1. Set Timeout:
We can set a timeout to a barrier, and if the specified threads do not reach the barrier within that time then an error will be thrown.
try {
cycbarrier.await(10, TimeUnit.MILISECONDS);
} catch (TimeoutException exception) {
System.out.println("Threads timeout");
}We can set a waiting time for other threads or parties to wait at the barrier, and after that, an error will be thrown to avoid an indefinite waiting period.
Example:
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
public class Main {
public static void main(String[] args) {
CyclicBarrier mybarrier = new CyclicBarrier(5);
new Thread(() -> {
try {
Thread.sleep(100);
mybarrier.await(10, TimeUnit.SECONDS);
System.out.println("Thread reached barrier point");
} catch (TimeoutException exception) {
System.out.println("Thread did not reached the barrier point, timeout");
} catch (Exception exception) {
exception.printStackTrace();
}
}).start();
}
}Output:
Explanation:
- Import necessary class for thread synchronization, specifying time, and handling TimeoutException.
- Create a CyclicBarrier instance with 5 threads, and create and start a thread.
- Simulate the thread for 100 milliseconds to show some work done by the thread.
- Set a timeout of 10 seconds for the barrier to wait for threads to invoke the await method.
- TimeoutException will be thrown if all the threads do not reach the barrier within 10 seconds.
- If all threads reach the barrier within 10 seconds, a message is printed indicating threads reached the barrier point. Else, a timeout exception is thrown by the message that the thread did not reach the barrier.
2. getNumberwaiting() Method:
The getNumberwaiting() method tracks the number of threads or parties that have invoked the await at the barrier.
int PartiesWaiting = cycbarrier.getNumberWaiting();We can get the number of waiting threads, which allows us to trace the execution progress.
Example
import java.util.concurrent.CyclicBarrier;
public class Main {
public static void main(String[] args) {
CyclicBarrier cyclicbarrier = new CyclicBarrier(8);
System.out.println("Threads are realeased");
new Thread(() -> {
try {
System.out.println("Thread 1 reached at common barrier point, waiting for other threads");
cyclicbarrier.await();
System.out.println("Thread 1 proceeded to next phase");
} catch (Exception exception) {
exception.printStackTrace();
}
}).start();
new Thread(() -> {
try {
System.out.println("Thread 2 reached at common barrier point, waiting for other threads");
cyclicbarrier.await();
System.out.println("Thread 2 proceeded to next phase");
} catch (Exception exception) {
exception.printStackTrace();
}
}).start();
new Thread(() -> {
try {
System.out.println("Thread 3 reached at common barrier point, waiting for other threads");
cyclicbarrier.await();
System.out.println("Thread 3 proceeded to next phase");
} catch (Exception exception) {
exception.printStackTrace();
}
}).start();
try {
Thread.sleep(500);
} catch (InterruptedException exception) {
exception.printStackTrace();
}
int waitingThreadsNumbers = cyclicbarrier.getNumberWaiting();
System.out.println("Total Threads waiting at barrier for others: " + waitingThreadsNumbers);
}
}Output:
Explanation:
- A CyclicBarrier is created with 8 parties or threads to reach a common execution point.
- Create and start 3 threads to reach a common execution or barrier point.
- Print a message that threads have reached a common point and are waiting for other threads to reach.
- Make the thread sleep for 500 milliseconds to allow other threads to reach the barrier.
- Print the number of threads waiting at the barrier with the getNumberWaiting() method.
3. Barrier interruption:
The isBroken() method tracks the thread interruption at the barrier point.
if (cycbarrier.isBroken()) {
System.out.println("Threads interrupted at the barrier.");
}With this method, we can track if any thread has been interrupted or not.
Example:
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
public class Main {
public static void main(String[] args) throws InterruptedException {
final int Threads = 4;
CyclicBarrier cycbarrier = new CyclicBarrier(Threads);
CountDownLatch interruptLatch = new CountDownLatch(1);
Thread Thread1 = new Thread(() -> {
try {
System.out.println("Thread 1 reached at barrier, waiting for other threads");
cycbarrier.await();
System.out.println("Thread 1 proceeded");
} catch (InterruptedException | BrokenBarrierException exe) {
System.out.println("Thread 1 interrupted at barrier.");
Thread.currentThread().interrupt();
interruptLatch.countDown();
}
});
Thread Thread2 = new Thread(() -> {
try {
System.out.println("Thread 2 reached at barrier, waiting for others");
cycbarrier.await();
System.out.println("Thread 2 proceeded");
} catch (InterruptedException | BrokenBarrierException exe) {
System.out.println("Thread 2 interrupted at barrier.");
}
});
Thread1.start();
Thread2.start();
Thread.sleep(2000);
Thread1.interrupt();
Thread2.interrupt();
interruptLatch.await();
if(cycbarrier.isBroken()){
System.out.println("Thread interruption has occurred. Barrier is broken.");
}
else{
System.out.println("No thread interruption occured");
}
}
}Output:
Explanation:
- Import class to handle broken barrier exceptions and thread coordination.
- Set the thread number to four and create CyclicBarrier.
- Create countdownLatch with thread to coordinate thread 1 interruption with the interruptLatch.
- Start both threads, allow them to sleep for 2 seconds, and interrupt both threads with the interrupt() method.
- Make interruptLatch wait to signal thread interruption.
- With the isBroken() method, check for thread interruption.
- A thread will print a statement indicating its interruption if it has been interrupted.
4. Barrier Action Variation:
We can specify a barrier action according to our requirements as:
- Standard Barrier Action: When all the threads reach a common execution point, the Standard Barrier Action performs synchronization maintenance.
CyclicBarrier cycbarrier = new CyclicBarrier(5, new BarrierAction());Code:
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.BrokenBarrierException;
public class Main {
public static void main(String[] args) {
CyclicBarrier barrier = new CyclicBarrier(2, new BarrierAction());
for (int i = 1; i {
try {
Thread.sleep(ThreadLocalRandom.current().nextInt(2000, 4000));
System.out.println("Thread " + thread + " waiting at the barrier");
barrier.await();
} catch (InterruptedException | BrokenBarrierException exe) {
exe.printStackTrace();
}
}).start();
}
}
static class BarrierAction implements Runnable {
public void run() {
System.out.println("All thread have reached at barrier, ");
}
}
}Output:
Explanation:
- Create a CyclicBArrier with two threads.
- Create and start a thread with a loop, and make the thread sleep to simulate some work.
- The thread reaches the barrier invokes the await() method, and waits for other threads for synchronization.
- Print a statement about the thread waiting at the barrier.
- When both threads reach a common barrier point for synchronization, execute a custom action.
Runnable Action: The Runnable interface represents an executable task or unit of work, which allows it to be run by a thread. We can define a separate runnable barrier action.
CyclicBarrier mybarrier = new CyclicBarrier(3, new RunnableAction());It will define a separate action to be performed for additional synchronization after the threads reach a common execution point.
Code:
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Main {
public static void main(String[] args) throws InterruptedException {
Runnable RunnableAction = new Runnable() {
//Override
public void run() {
System.out.println("Perform additional runnable barrier action");
int Total = 1+2;
System.out.println("Total Sum :"+ Total);
}
};
CyclicBarrier cycbarrier = new CyclicBarrier(3, RunnableAction);
Thread T1 = new Thread(() -> {
try {
Thread.sleep(2000);
System.out.println("Thread 1 reached");
cycbarrier.await();
} catch (InterruptedException | BrokenBarrierException exe) {
exe.printStackTrace();
}
});
Thread T2 = new Thread(() -> {
try {
Thread.sleep(3000);
System.out.println("Thread 2 reached");
cycbarrier.await();
} catch (InterruptedException | BrokenBarrierException exe) {
exe.printStackTrace();
}
});
T1.start();
T2.start();
try {
System.out.println("Main thread reached at the common barrier point");
cycbarrier.await();
} catch (InterruptedException | BrokenBarrierException exe) {
exe.printStackTrace();
}
}
}Output:
Explanation:
- Create a CyclicBarrier with three synchronized threads and a runnable action to be performed.
- Two threads sleep for some time to simulate some work and wait at the barrier.
- A customer-runnable action executes when all three threads reach a barrier.
- A Runnable action calculates the sum of two numbers, and the system prints its result after it trips the barrier.
When to use CyclicBarrier in Java Program
In Java programming, CyclicBarrier serves to synchronize different scenarios, ensuring coordination is a priority. To illustrate its function, consider a gaming scenario where the game only starts after all players have logged in.
Code:
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
public class Main {
public static void main(String[] args) {
CyclicBarrier mybarrier = new CyclicBarrier(4, new BarrierAction());
System.out.println("Players logging in \n");
for (int i = 0; i Output:
Explanation:
- Import the required class for handling exceptions and synchronizing threads.
- Create a CyclicBarrier with 4 synchronizing threads that correspond to 4 players who will be logging in to play the game and define barrier action to execute some action after all players reach the barrier point.
- Run a loop for each player to log in with a shared barrier.
- The run() Method will print the message that players started logging in, simulate players logging in for 1 second, and print the message that players have reached the start point i.e., barrier.
- Threads invoke the await method when they reach the barrier and wait for other threads.
- When all the players invoke the await method, the barrier will trip, and a message will be printed that all the players have reached the game’s starting point and the game is starting.
- These make sure that the game starts when all players have reached and allow them to have an impartial and consistent experience.
Comparison with Other Synchronization Mechanisms
CountDownLatch vs. CyclicBarrier in Java
| Features | CountDownLatch | CyclicBarrier |
| Mechanism | Synchronize one time, and wait for a set of events to complete | Synchronize repeatedly, and wait for other threads to reach a common point |
| Functionality | Call countdown() until the count is zero | Threads wait for other threads at a barrier before proceeding |
| Reusability | Used once, it cannot be reset | Reusable for multiple synchronization after resetting |
| Threads | Threads countdown until it reaches zero | Thread wait for other threads at a barrier |
| awaits() Method | Blocks thread until the count is zero | Blocks thread until a specific number of threads reach a barrier |
| Barrier Action | No | Gets executed after tripping the barrier |
CyclicBarrier java vs. Phaser Java
| Features | CyclicBarrier | Phaser |
| Mechanism | Fixed count of threads synchronize at the barrier point | Parties register or deregister during synchronization |
| Functionality | Thread wait for other threads at barrier point before proceeding | Execute multiple phases with dynamic parties participation |
| Reusability | Reusable for multiple synchronization after resetting | Reusable for multiple synchronizations after resetting for different phases |
| Threads | Fixed thread counts are initialized | Dynamic thread participation during synchronization |
| Thread blocking | Blocks thread with await() method until a specified number of threads reach a barrier. | Blocks thread until the next phase with the ‘awaitAdvance()’ method |
| Dynamic participation | Not supported | Support dynamic participation of threads |
| Barrier Action | Gets executed after tripping the barrier | Gets executed after completion of each phase. |
Common Pitfalls and Troubleshooting
When using CyclicBarrier, we might face some problems during our execution process, and to avoid execution issues, we need to be careful about our coding process. Here are some common issues and solutions to them and some additional tips for efficient programming:
Common Pitfalls:
1. Thread Count Challenges:
The number of threads during its initialization might be greater than the number of threads invoking the await() method. This problem will never let the barrier trip, and it will cause threads to wait indefinitely.
Solution: Make sure that the number of threads is the same as that we are expecting to reach a barrier point.
2. Thread Termination:
If the thread terminates before reaching the barrier point, it might cause an error in the synchronization of other parties.
Solution: ensure that all the participating threads reach the barrier or terminate properly after reaching the barrier.
3. Barrier Action Failure:
Barrier Action may throw an exception to corrupt the barrier-tripping.
Solution: Carefully use logging and handling mechanisms to handle exceptions.
4. Interrupting await():
Threads waiting at the barrier get interrupted and throw an InterruptedException.
Solution: To handle InterruptedException, use the try-catch block properly to choose between interruption and termination of a thread.
Troubleshooting:
- Concise coding: write concise Java docs for barrier coding to enhance the coding execution process and readability.
- Logging and Testing: use logging to track the execution process and keep testing multithreaded code with CyclicBarrier to identify synchronization errors.
- Reset Barrier: reset the barrier after it trips while reusing for multiple cycles
- Alternate Tools: use CountDownLatch for one-phase execution and Phaser for executing multiple phases.
- Thread count: ensure that the number of threads at initialization matches the thread for synchronization.
Reusing CyclicBarrier
CyclicBarrier can be reused for multiple-thread synchronization; we can reuse them after resetting without creating a new CyclicBarrier.
Code:
import java.util.concurrent.CyclicBarrier;
public class Main {
private static final int Parties_Number = 2;
private static final CyclicBarrier cycbarrier = new CyclicBarrier(Parties_Number, new BarrierAction());
public static void main(String args[]) {
CyclicBarrier cycbarrier = new CyclicBarrier(Parties_Number, new BarrierAction());
Thread T1 = new Thread(new ImageProcessor("Thread no. 1", cycbarrier));
Thread T2 = new Thread(new ImageProcessor("Thread no. 2", cycbarrier));
T1.start();
T2.start();
System.out.println("First cycle started for processing image \n");
try {
T1.join();
T2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
cycbarrier.reset();
Thread T3 = new Thread(new ImageProcessor("Thread no. 3", cycbarrier));
Thread T4 = new Thread(new ImageProcessor("Thread no. 4", cycbarrier));
T3.start();
T4.start();
System.out.println("Second cycle started for processing image \n");
}
}
class ImageProcessor implements Runnable {
private String threadName;
private CyclicBarrier cycbarrier;
ImageProcessor(String threadName, CyclicBarrier cycbarrier) {
this.threadName = threadName;
this.cycbarrier = cycbarrier;
}
public void run() {
System.out.println("\n" + threadName + " is processing image. \n");
try {
Thread.sleep((long) (Math.random() * 2000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + " has completed image processing. Waiting at the barrier for other threads. \n");
try {
cycbarrier.await();
} catch (Exception e) {
e.printStackTrace();
}
}
}
class BarrierAction implements Runnable {
public void run() {
System.out.println("All threads have completed image processing. Start Further processing.\n");
}
}Output:
Explanation:
we can learn about the cyclic synchronization of a barrier where the image processing task is carried by two T1 and T2 threads in the first cycle. When all threads complete the first image processing cycle, the system resets the barrier for the next cycle. In this cycle, threads T3 and T4 process images in the same manner as in cycle 1. These explain the cyclic synchronization of threads, and we can use the same cycle for multiple image-processing tasks after resetting the barrier. This method helps in reusability and maintaining synchronization in our program.
Conclusion
The CyclicBarrier class in Java allows us to handle multiple tasks in concurrent programming where synchronization is the priority; it has valuable use in parallel computing, research, and development. CyclicBarrier suspends execution until all threads reach a common barrier point, carefully handling the thread count. CyclicBarrier makes programming flexible, maintains consistency and data integrity, and handles time-crucial events.
FAQs (Frequently Asked Questions)
Q1) How does CyclicBarrier handle the thread arriving late after tripping of CyclicBarrier?
Answer: if a thread comes late at a barrier point, then the CyclicBarrier does not reset instantly. Instead, it will make the thread wait for the next cycle, and after completing the first cycle, the waiting thread will join in the next cycle.
Q2) how do I recursively use CyclicBarrier?
Answer: Yes, we can use CyclicBarrier recursively, where we can define a new logic for synchronizing within a barrier action constructor provided at the first CyclicBarrier. A thread, before reaching a barrier, can set its cyclic barrier and make the initial barrier await. These allow complex and hierarchical synchronization.
Q3) Can I use the CyclicBarrier instance for cross-thread synchronization
Answer: No, a CyclicBarrier instance will stick to a single thread group it was created within. Each thread group will have its own CyclicBarrier instance to maintain synchronization and prevent conflict. Different thread groups cannot share cyclic barriers, and attempting to use a single CyclicBarrier across them will lead to unexpected performance.
Recommend
We hope that this EDUCBA information on “Java CyclicBarrier” was beneficial to you. You can view EDUCBA’s recommended articles for more information.
- Diamond Operator in Java
- Java Dot Operator
- Returning Multiple Values in Java
- Interchange Diagonal Elements in Java Program
The post Java CyclicBarrier appeared first on EDUCBA.
This post first appeared on Free Online CFA Calculator Training Course | EduCB, please read the originial post: here
