1. Introduction
  2. Navigation
    1. By topic
    2. FAQs
    3. Index
  5. Part 1: guide
  6. Introduction
  7. Concurrent programming
  8. Async and await
  9. Advanced async/await topics
  10. IO and issues with blocking
  11. Concurrency primitives
  12. Channels, locking, and synchronization
  13. Tools for async programming
  14. Destruction and clean-up
  15. Futures
  16. Runtimes
  17. Timers and signal handling
  18. Async iterators (streams)
  20. Part 2: reference
  21. Implementing futures and streams
  22. Alternate runtimes
  23. Implementing your own runtime
  24. async in sync, sync in async
  25. Async IO: readiness vs completion, and io_uring
  26. Design patterns
  27. Cancellation
  28. Starvation
  29. Pinning
  30. Async and FFI
  31. Comparing async programming in Rust to other languages
  32. The implementation of async/await in rustc
  33. Structured concurrency?
  35. Old chapters
  36. Getting Started
    1. Why Async?
    2. The State of Asynchronous Rust
    3. async/.await Primer
  38. Under the Hood: Executing Futures and Tasks
    1. The Future Trait
    2. Task Wakeups with Waker
    3. Applied: Build an Executor
    4. Executors and System IO
  40. async/await
  41. Pinning
  42. Streams
    1. Iteration and Concurrency
  44. Executing Multiple Futures at a Time
    1. join!
    2. select!
    3. Spawning
    4. TODO: Cancellation and Timeouts
    5. TODO: FuturesUnordered
  46. Workarounds to Know and Love
    1. ? in async Blocks
    2. Send Approximation
    3. Recursion
    4. async in Traits
  48. The Async Ecosystem
  49. Final Project: HTTP Server
    1. Running Asynchronous Code
    2. Handling Connections Concurrently
    3. Testing the Server
  51. TODO: I/O
    1. TODO: AsyncRead and AsyncWrite
  53. TODO: Asynchronous Design Patterns: Solutions and Suggestions
    1. TODO: Modeling Servers and the Request/Response Pattern
    2. TODO: Managing Shared State
  55. Appendix: Translations of the Book