Runtimes, Wakers, and the Reactor-Executor Pattern

If anyone tries to call poll on our Coroutine again, we will panic, so the caller must make sure to keep track of when the future returns PollState::Ready and make sure to not call poll on it ever again. The last thing we do before we get to our main function is create a new Coroutine in a function we call async_main. This way, we can keep the changes to a minimum when we start talking about async/await in the last part of this chapter:

ch07/a-coroutine/src/main.rs
fn async_main() -> impl Future<Output = ()> {
    Coroutine::new()
}

So, at this point, we’re finished writing our coroutine and the only thing left is to write some logic to drive our state machine through its different stages of the main function.

One thing to note here is that our main function is just a regular main function. The loop in our main function is what drives the asynchronous operations to completion:

ch07/a-coroutine/src/main.rs
fn main() {
    let mut future = async_main();
    loop {
        match future.poll() {
            PollState::NotReady => {
                println!(“Schedule other tasks”);
            },
            PollState::Ready(_) => break,
        }
        thread::sleep(Duration::from_millis(100));
    }
}

This function is very simple. We first get the future returned from async_main and then we call poll on it in a loop until it returns PollState::Ready.

Every time we receive a PollState::NotReady in return, the control is yielded back to us. we could do other work here, such as scheduling another task, if we want to, but in our case, we just print Schedule other tasks.

We also limit how often the loop is run by sleeping for 100 milliseconds on every call. This way we won’t be overwhelmed with printouts and we can assume that there are roughly 100 milliseconds between every time we see “Schedule other tasks” printed to the console.

If we run the example, we get this output:
Program starting
FIRST POLL – START OPERATION
Schedule other tasks
Schedule other tasks
Schedule other tasks
Schedule other tasks
Schedule other tasks
Schedule other tasks
HTTP/1.1 200 OK
content-length: 11
connection: close
content-type: text/plain; charset=utf-8
date: Tue, 24 Oct 2023 20:39:13 GMT
HelloWorld1
FIRST POLL – START OPERATION
Schedule other tasks
Schedule other tasks
Schedule other tasks
Schedule other tasks
HTTP/1.1 200 OK
content-length: 11
connection: close
content-type: text/plain; charset=utf-8
date: Tue, 24 Oct 2023 20:39:13 GMT
HelloWorld2

By looking at the printouts, you can get an idea of the program flow.

1. First, we see Program starting, which executes at the start of our coroutine.
2. We then see that we immediately move on to the FIRST POLL – START OPERATION message that we only print when the future returned from our HTTP client is polled the first time.
3. Next, we can see that we’re back in our main function, and at this point, we could theoretically go ahead and run other tasks if we had any
4. Every 100 ms, we check if the task is finished and get the same message telling us that we can schedule other tasks
5. Then, after roughly 600 milliseconds, we receive a response that’s printed out
6. We repeat the process once more until we receive and print out the second response from the server

Congratulations, you’ve now created a task that can be paused and resumed at different points, allowing it to be in progress.