# 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.

# Examples

    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]

####

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

[src]

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`.

# Examples

    use std::sync::Barrier;

    let barrier = Barrier::new(10);Run

####

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

[src]

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`.

# Examples

    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

## Trait Implementations

###

`impl Debug for Barrier`

1.16.0
[src]

####

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

[src]

Formats the value using the given formatter. Read more

## Auto Trait Implementations

###

`impl Send for Barrier`

###

`impl Sync for Barrier`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse 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`)