Abortable：悬而未决的期货？

Question

我正在使用Abortable crate 来暂停 Future 的执行。 假设我有一个流产的未来，其中异步 function 本身正在等待其他异步函数。 我的问题是，如果我中止根 Future，子 Futures 会同时立即中止，还是会悬空？

我阅读了Abortable的源代码，特别是try_poll的代码：

fn try_poll<I>(
        mut self: Pin<&mut Self>,
        cx: &mut Context<'_>,
        poll: impl Fn(Pin<&mut T>, &mut Context<'_>) -> Poll<I>,
    ) -> Poll<Result<I, Aborted>> {
        // Check if the task has been aborted
        if self.is_aborted() {
            return Poll::Ready(Err(Aborted));
        }

        // attempt to complete the task
        if let Poll::Ready(x) = poll(self.as_mut().project().task, cx) {
            return Poll::Ready(Ok(x));
        }

        // Register to receive a wakeup if the task is aborted in the future
        self.inner.waker.register(cx.waker());

        // Check to see if the task was aborted between the first check and
        // registration.
        // Checking with `is_aborted` which uses `Relaxed` is sufficient because
        // `register` introduces an `AcqRel` barrier.
        if self.is_aborted() {
            return Poll::Ready(Err(Aborted));
        }

        Poll::Pending
    }

我的理解是，一旦调用abort ，它就会传播到下游 Futures，即当根 Future 被中止时，它将停止轮询其子 Future（因为Poll::Ready(Err(Aborted))将被返回） ，这将反过来停止轮询它的孩子。 如果这个推理是正确的，那么调用 abort 的效果是立竿见影的。
另一个论点是，如果 Future 是基于拉取的，则应该首先调用根节点，然后传播到子任务，直到叶节点被调用并中止（然后 go 返回到根节点）。 这意味着在调用abort方法和叶 Future 实际停止轮询之间存在延迟。 可能是相关的，但这篇博文提到了悬空任务，我担心是这种情况。
例如，这是我写的一个玩具示例：

use futures::future::{AbortHandle, Abortable};
use tokio::{time::sleep};
use std::{time::{Duration, SystemTime}};

/*
 *       main
 *         \
 *       child
 *         | \
 *        |   \
 *    leaf1   leaf2
 */
 

async fn leaf2() {
    println!("This will not be printed")
}

async fn leaf1(s: String) {
    println!("[{:?}] ====== in a ======", SystemTime::now());
    for i in 0..100000 {
        println!("[{:?}] before sleep i is {}", SystemTime::now(), i);
        sleep(Duration::from_millis(1)).await;
        println!("[{:?}] {}! i is {}", SystemTime::now(), s.clone(), i);
    }
}
 
async fn child(s: String) {
    println!("[{:?}] ====== in child ======", SystemTime::now());
    leaf1(s.clone()).await;
    leaf2().await
}
 
#[tokio::main]
async fn main() {
    let (abort_handle, abort_registration) = AbortHandle::new_pair();
    let result_fut = Abortable::new(child(String::from("Hello")), abort_registration);

    tokio::spawn(async move {
        println!("{:?} ^^^^^ before sleep ^^^^^", SystemTime::now());
        sleep(Duration::from_millis(100)).await;
        println!("{:?} ^^^^^ after sleep, about to abort ^^^^^", SystemTime::now());
        abort_handle.abort();
        println!("{:?} ***** operation aborted *****", SystemTime::now());
    });

    println!("{:?} ====== before main sleeps ======", SystemTime::now());
    sleep(Duration::from_millis(5)).await;
    println!("{:?} ====== after main wakes up from sleep and now getting results \
            ======", SystemTime::now());
    result_fut.await.unwrap();
}

Rust 操场
我个人更倾向于第一个论点，即根的流产和叶的流产之间没有延迟，因为叶不需要知道它需要中止（叶仅在根告诉它时才拉动）。 上面的例子打印了child被执行的时间和root被中止的时间。 child 的执行总是在 root 被中止之前，但是我不确定这是否可以证明我的第一个论点是正确的，所以我想知道大家的想法！

Answer 1

是的，因为 future 需要轮询才能执行，但如果中止则不会轮询，子 futures 也不会被轮询，因此执行将立即停止。

当然，执行只会在到达下一个屈服点后停止，使用tokio::spawn()生成的任务不会停止。