std::sync::Barrier - Rust
Description: API documentation for the Rust `Barrier` struct in crate `std`.
Keywords: rust, rustlang, rust-lang, Barrier

# Struct std::sync::Barrier 1.0.0 [−] [src]

    pub struct Barrier { /* fields omitted */ }

A barrier enables multiple threads to synchronize the beginning of some computation.

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

    let mut handles = Vec::with_capacity(10);
    let barrier = Arc::new(Barrier::new(10));
    for _ in 0..10 {
        let c = barrier.clone();
        // The same messages will be printed together.
        // You will NOT see any interleaving.
        handles.push(thread::spawn(move|| {
            println!("before wait");
            c.wait();
            println!("after wait");
        }));
    }
    // Wait for other threads to finish.
    for handle in handles {
        handle.join().unwrap();
    }Run

## Methods

### `impl Barrier`
[src]

#### `fn new(n: usize) -> Barrier`

Creates a new barrier that can block a given number of threads.

A barrier will block `n`-1 threads which call `wait` and then wake up all threads at once when the `n`th thread calls `wait`.

#### `fn wait(&self) -> BarrierWaitResult`

Blocks the current thread until all threads have rendezvoused here.

Barriers are re-usable after all threads have rendezvoused once, and can be used continuously.

A single (arbitrary) thread will receive a `BarrierWaitResult` that returns `true` from `is_leader` when returning from this function, and all other threads will receive a result that will return `false` from `is_leader`

## Trait Implementations

### `impl Debug for Barrier`
1.15.0
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result`

Formats the value using the given formatter.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)