Rust - Thread Synchronization using Barrier

This post is about Rust thread synchronization with Barrier using std::sync::Barrier which is part of Rust’s standard library. Therefore, we do not need external dependencies to make things work.

Basic Idea of Barrier

The basic idea of using barriers is to pause threads at a certain point until we reach a certain count of started and paused threads. Only then the “barrier” breaks and allows all the threads to proceed with the execution.

Rust Thread Synchronization Codes

The following codes use a Barrier and force all threads to wait. Then, once all the threads invoke the wait function, the barrier breaks and allow all the threads to continue processing.

use std::sync::{Arc, Barrier};
use std::thread;
use std::thread::JoinHandle;

fn main() {

    let mut handles:Vec<JoinHandle<()>> = Vec::with_capacity(5);
    let barrier = Arc::new(Barrier::new(5));

    for i in 0..5 {
        let c:Arc<Barrier> = barrier.clone();
        handles.push(thread::spawn(move|| {
            println!("Thread {} paused...awaiting other threads", i);
            c.wait();
            println!("Thread {} processing done", i);
        }));
    }

    // Wait for all threads to complete execution
    for handle in handles {
        handle.join().unwrap();
    }
}

use std::sync::{Arc, Barrier};

use std::thread;

use std::thread::JoinHandle;

fn main() {

let mut handles:Vec<JoinHandle<()>> = Vec::with_capacity(5);

let barrier = Arc::new(Barrier::new(5));

for i in 0..5 {

let c:Arc<Barrier> = barrier.clone();

handles.push(thread::spawn(move|| {

println!("Thread {} paused...awaiting other threads", i);

c.wait();

println!("Thread {} processing done", i);

}));

}

// Wait for all threads to complete execution

for handle in handles {

handle.join().unwrap();

}

The barrier waits for 5 threads in waiting mode before it allows them to proceed. Note that we also use Arc to wrap a Barrier instance. Then, use invoke the wait function on an Arc instance. When we invoke the wait function on an Arc instance, we increment the internal counter with the Barrier instance.

When we run the codes, we get the following output. Note that lines 6-10 are not guaranteed to be the same every time the codes run.

Thread 0 paused...awaiting other threads
Thread 1 paused...awaiting other threads
Thread 2 paused...awaiting other threads
Thread 3 paused...awaiting other threads
Thread 4 paused...awaiting other threads
Thread 4 processing done
Thread 3 processing done
Thread 1 processing done
Thread 0 processing done
Thread 2 processing done