comprehensive-rust/src/async.md

# Async Rust

"Async" is a concurrency model where multiple tasks are executed concurrently by
executing each task until it would block, then switching to another task that is
ready to make progress. The model allows running a larger number of tasks on a
limited number of threads. This is because the per-task overhead is typically
very low and operating systems provide primitives for efficiently identifying
I/O that is able to proceed.

Rust's asynchronous operation is based on "futures", which represent work that
may be completed in the future. Futures are "polled" until they signal that
they are complete.

Futures are polled by an async runtime, and several different runtimes are
available.

## Comparisons

 * Python has a similar model in its `asyncio`. However, its `Future` type is
   callback-based, and not polled. Async Python programs require a "loop",
   similar to a runtime in Rust.

 * JavaScript's `Promise` is similar, but again callback-based. The language
   runtime implements the event loop, so many of the details of Promise
   resolution are hidden.
Add an "async" session (#496) * beginning of an Async section * address review comments * Add futures page (#497) NOTE: `mdbook test` does not allow code samples to reference other crates, so they must be marked as `compile_fail`; see #175. * Add Runtimes & Tasks (#522) These concepts are closely related, and there's not much else to know about runtimes other than "they exist". This removes the bit about futures being "inert" because it doesn't really lead anywhere. * Async chapter (#524) * Add async channels chapter * Async control flow * Async pitfalls * Separate in multiple chapters + add daemon section * Merge reentering threads in blocking-executor * async_trait * Async fixes (#546) * Async: some ideas for simplifying the content (#550) * Simplify the async-await slide * Shorten futures and move it up * Add a page on Tokio * Modifications to the async section (#556) * Modifications to the async section * Remove the "Daemon" slide, as it largely duplicates the "Tasks" slide. The introduction to the "Control Flow" section mentions tasks as a kind of control flow. * Reorganize the structure in SUMMARY.md to correspond to the directory structure. * Simplify the "Pin" and "Blocking the Executor" slides with steps in the speaker notes to demonstrate / fix the issues. * Rename "join_all" to "Join". * Simplify some code samples to shorten them, and to print output rather than asserting. * Clarify speaker notes and include more "Try.." suggestions. * Be consistent about where `async` blocks are introduced (in the "Tasks" slide). * Explain `join` and `select` in prose. * Fix formatting of section-header slides. * Add a note on async trait (#558) --------- Co-authored-by: sakex <alexandre@senges.ch> Co-authored-by: rbehjati <razieh@google.com> 2023-04-14 16:06:50 +02:00			`# Async Rust`

			`"Async" is a concurrency model where multiple tasks are executed concurrently by`
			`executing each task until it would block, then switching to another task that is`
			`ready to make progress. The model allows running a larger number of tasks on a`
			`limited number of threads. This is because the per-task overhead is typically`
			`very low and operating systems provide primitives for efficiently identifying`
			`I/O that is able to proceed.`

			`Rust's asynchronous operation is based on "futures", which represent work that`
			`may be completed in the future. Futures are "polled" until they signal that`
			`they are complete.`

			`Futures are polled by an async runtime, and several different runtimes are`
			`available.`

			`## Comparisons`

			* Python has a similar model in its `asyncio`. However, its `Future` type is
			`callback-based, and not polled. Async Python programs require a "loop",`
			`similar to a runtime in Rust.`

			* JavaScript's `Promise` is similar, but again callback-based. The language
			`runtime implements the event loop, so many of the details of Promise`
			`resolution are hidden.`