One approach I'm personally fond of is actor-style async programming with tokio. It's easy to mingle timers with receiving messages from channels, which is quite powerful. This post by Alice Rhyl is a good description of the idea: https://ryhl.io/blog/actors-with-tokio/
Rust Lang
Rules [Developing]
Observe our code of conduct
- Strive to treat others with respect, patience, kindness, and empathy.
- We observe the Rust Project Code of Conduct.
- Submissions must be on-topic
- Posts must reference Rust or relate to things using Rust. For content that does not, use a text post to explain its relevance.
- Post titles should include useful context.
- For Rust questions, use the stickied Q&A thread. [TBD]
- Arts-and-crafts posts are permitted on weekends.
- No meta posts; message the mods instead.
Constructive criticism only
- Criticism is encouraged, though it must be constructive, useful and actionable.
- If criticizing a project on GitHub, you may not link directly to the project’s issue tracker. Please create a read-only mirror and link that instead.
- Keep things in perspective
- A programming language is rarely worth getting worked up over.
- No zealotry or fanaticism.
- Be charitable in intent. Err on the side of giving others the benefit of the doubt.
No endless relitigation
- Avoid re-treading topics that have been long-settled or utterly exhausted.
- Avoid bikeshedding.
- This is not an official Rust forum, and cannot fulfill feature requests. Use the official venues for that.
No low-effort content
- Showing off your new projects is fine
No memes or image macros
- Please find other communities to post memes
No NSFW Content
- There are many other NSFW communities, let’s keep this related to the language
This.
tokio tasks are green threads. https://docs.rs/tokio/latest/tokio/task/
tokio also offers a variety of channels for synchronization between tasks. https://docs.rs/tokio/latest/tokio/sync/index.html
Wait is there a difference between coroutines and async/await? I thought they were practically the same model.
Coroutines are one means of implementing async; the way they are implemented in Rust is more like building a state machine out of the async function. It can still be mapped to coroutines, and there are probably crates that use async and macros to make coroutines usable on stable, but the effort to have a stable language feature is still ongoing, with https://lang-team.rust-lang.org/design_notes/general_coroutines.html giving the overview.
You can use mpsc for channels, there's oneshots too
Super interested to see if this is true as well. AFAIK Rust focuses on threading and async/await with Tokio being the main focus.
I believe there is some support of green threads with Tokio configuration but I'm not 100% sure and am just writing off the top of my head because nobody has responded yet.