This crate provides experimental support for multi-producer/multi-consumer channels. This includes bounded synchronous and asynchronous channels in addition to an unbounded asynchronous channel.
There is also rudimentary support for "selecting" from one of several synchronization events (sending or receiving).
Dual-licensed under MIT or the UNLICENSE.
Documentation
http://burntsushi.net/rustdoc/chan/.
Caveats
This implementation is simplistic to the point that there may be serious
performance issues. However, it is possible that it may be good enough (or
may one day become good enough). In particular, there are no fancy lock-free
algorithms or lightweight threads. Everything is implemented with plain old
condition variables and mutexes. Notably, this crate uses no unsafe
blocks.
The API presented here also differs substantially from the APIs offered by
std::sync. This is at least partly due to providing a
multi-producer/multi-consumer queue (std::sync provides
multi-producer/single-consumer), but also to keep the implementation simple.
This has some interesting side effects:
- There is no distinction between "senders" and "receivers." There's just channels.
- As a result, clients must call
closeexplicitly on a channel when there are no more senders remaining. Neglecting to do this may lead to memory leaks depending on how receivers behave. - The implementation of
selectin this crate can handle both send and receive synchronization events, but both the API and implementation are questionable at best. - A crippled version of
selectcalledchooseis provided which only supports receive synchronization events. However, it should be much faster in loops than its more generalselect.
Finally, much of the semantics applied in this crate were directly inspired by Go's channels.