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. More async/await topics
  10. IO and issues with blocking
  11. Composing futures concurrently
  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 and cancellation safety
  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. Send Approximation
    2. Recursion
    3. 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