# Function std::sync::mpsc::sync_channel 1.0.0 [−] [src]

    pub fn sync_channel<T>(bound: usize) -> (SyncSender<T>, Receiver<T>)

Creates a new synchronous, bounded channel. All data sent on the `SyncSender` will become available on the `Receiver` in the same order as it was sent. Like asynchronous `channel`s, the `Receiver` will block until a message becomes available. `sync_channel` differs greatly in the semantics of the sender, however.

This channel has an internal buffer on which messages will be queued. `bound` specifies the buffer size. When the internal buffer becomes full, future sends will block waiting for the buffer to open up. Note that a buffer size of 0 is valid, in which case this becomes "rendezvous channel" where each `send` will not return until a `recv` is paired with it.

The `SyncSender` can be cloned to `send` to the same channel multiple times, but only one `Receiver` is supported.

Like asynchronous channels, if the `Receiver` is disconnected while trying to `send` with the `SyncSender`, the `send` method will return a `SendError`. Similarly, If the `SyncSender` is disconnected while trying to `recv`, the `recv` method will return a `RecvError`.

# Examples

    use std::sync::mpsc::sync_channel;
    use std::thread;

    let (sender, receiver) = sync_channel(1);

    // this returns immediately
    sender.send(1).unwrap();

    thread::spawn(move|| {
        // this will block until the previous message has been received
        sender.send(2).unwrap();
    });

    assert_eq!(receiver.recv().unwrap(), 1);
    assert_eq!(receiver.recv().unwrap(), 2);Run

# 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`)