crossbeam VS signal-hook

Crossbeam isn't async[0]. It can multiplex with itself (via the `select!` macro), but not with anything else.

[0]: https://github.com/crossbeam-rs/crossbeam/issues/896

Shooting from the hip, crossbeam might be a good candidate for understanding the thread safety aspects of Rust. I kind of feel like this is probably "too big" of a project if you're just learning, but I can't think of something smaller off the top of my head that would be suitable.

I am familiar with crossbeam channels, but now I need to work with python, and I was looking for a similar library.

In the C++ example you create a naive mpsc queue using a std queue and a mutex, while in the rust example you use `std::sync::mpsc` which is now implemented internally using https://github.com/crossbeam-rs/crossbeam .

There are more in the ecosystem like in https://crates.io/crates/crossbeam

The crossbeam crate offers a powerful alternative to standard channels with support for the Select operation, timeouts, and more.

From this project: https://github.com/crossbeam-rs/crossbeam

I want to use signal-hook-tokio from here: https://github.com/vorner/signal-hook/blob/master/signal-hook-tokio/src/lib.rs. It says that I need to enable a feature to make the next() method works. I did that, but I still get an error:

If you're interested in the techniques people use here, you might take a look at signalfd - which gives you a way to read signals as-if through a file pipe (so you can use it with things like select/epoll loops) - or signal-hook's implementation of the signal-pipe pattern (which makes use of the fact that write is on the list of async-signal-safe system calls).

This may change, but as of now, the crate documentation has 2 examples on the front page - one that is very simple, which we will take a closer look at below, and one that is overly complex, which uses features that are unlikely to be commonly needed, and won't compile without enabling extra features. We'll slowly work our way from the simple example, to a more complex one that resembles the one in the documentation.