Support channels with multiple receivers

[jonhoo]

It would be useful if rust provided a channel that supported a single sender and multiple receivers. Specifically, a channel where any item sent on the channel is received by exactly one receiver (i.e. not broadcast).

One example of where this might be used is to have a worker pool for a TCP server:

use std::net;
use std::thread;
use std::sync::mpsc;

let listener = net::TcpListener::bind("127.0.0.1:80").unwrap();

fn handle_clients(streams: mpsc::Receiver<net::TcpStream>) {
    for s in streams.iter() {
      // handle s
    }
}

let (tx, rx) = mpsc::channel();
let pool = (1..10).map(|_| {
  let local_rx = rx.clone();
  thread::spawn(move || {
    handle_clients(local_rx);
  });
}).collect();

// accept connections and process them, spawning a new thread for each one
for stream in listener.incoming() {
    match stream {
        Ok(stream) => {
            tx.send(stream);
        }
        Err(e) => { /* connection failed */ }
    }
}

// close the socket server
drop(listener);

Since Receiver is not Sync nor Copy, this obviously doesn't currently work. There has been some discussion in #2158 on a similar topic, though the objections there seem to be about full-duplex channels rather than single-writer-multi-reader channels.

[jdm]

This is the same as storing Arc<Mutex<Receiver<T>>> wherever you want multiple receivers, right?

[jdm]

Oh, I guess that doesn't necessarily work fairly if you're using blocking receive, as whichever one grabs the lock first would win.

[alexcrichton]

This is a dupe of rust-lang/rfcs#848, so closing in favor of that, but @jdm's suggestion is the current method to get a "multi-receiver" situation as well.

[marcusklaas]

FYI, there is a crate which provides this functionality: https://github.com/mahkoh/comm/