Book Image

Asynchronous Programming in Rust

By : Carl Fredrik Samson
5 (2)
Book Image

Asynchronous Programming in Rust

5 (2)
By: Carl Fredrik Samson

Overview of this book

Step into the world of asynchronous programming with confidence by conquering the challenges of unclear concepts with this hands-on guide. Using functional examples, this book simplifies the trickiest concepts, exploring goroutines, fibers, futures, and callbacks to help you navigate the vast Rust async ecosystem with ease. You’ll start by building a solid foundation in asynchronous programming and explore diverse strategies for modeling program flow. The book then guides you through concepts like epoll, coroutines, green threads, and callbacks using practical examples. The final section focuses on Rust, examining futures, generators, and the reactor-executor pattern. You’ll apply your knowledge to create your own runtime, solidifying expertise in this dynamic domain. Throughout the book, you’ll not only gain proficiency in Rust's async features but also see how Rust models asynchronous program flow. By the end of the book, you'll possess the knowledge and practical skills needed to actively contribute to the Rust async ecosystem.
Table of Contents (16 chapters)
Free Chapter
1
Part 1:Asynchronous Programming Fundamentals
5
Part 2:Event Queues and Green Threads
8
Part 3:Futures and async/await in Rust

Step 2 – Implementing a proper Executor

In this step, we’ll create an executor that will:

  • Hold many top-level futures and switch between them
  • Enable us to spawn new top-level futures from anywhere in our asynchronous program
  • Hand out Waker types so that they can sleep when there is nothing to do and wake up when one of the top-level futures can progress
  • Enable us to run several executors by having each run on its dedicated OS thread

Note

It’s worth mentioning that our executor won’t be fully multithreaded in the sense that tasks/futures can’t be sent from one thread to another, and the different Executor instances will not know of each other. Therefore, executors can’t steal work from each other (no work-stealing), and we can’t rely on executors picking tasks from a global task queue.

The reason is that the Executor design will be much more complex if we go down that route, not only because of the added...