如何在不等待的情况下开始执行？
spawn任务。
这似乎是所有时雄API的一个要求，即“启动未来的执行，而不等待当前fn范围内的结果”，例如spawn_local
是的，因为你正在生成一个任务，所以这个任务有可能比拥有这个项目的任何东西都存在，从而导致一个悬空引用，这是不允许的。事实上，在使用spawn_local时，这几乎是一个保证：它将在同一个线程（/scheduler）上产生一个任务，并且在当前任务退出或终止之前，该任务根本无法运行。
另一种方法是使用“范围任务”（不必立即等待，但最终必须加入）。然而，到目前为止，时雄对结构化并发（有作用域的任务）的支持已经胎死腹中。因此Rust编译器无法知道一个任务没有从初始化它的作用域中“逃逸”，因此它必须假设它确实如此，因此任务捕获的任何内容都应该能够超过当前作用域。

这是wg-async scope proposal，这是tokio scoped tasks issue
当我遇到类似的问题时，我首先研究了async-scoped（crossbeam::scope的异步版本，或rayon::scope）。最后，我决定写一个新的类型，它为每个未来产生一个任务（或者，在我的例子中是Stream<Item=String>），当它被删除时，它确保任务完成。这本质上是“范围”思想的穷人实现。

// how long to wait to print remaining container logs
const DRAIN_LOGS_TIMEOUT: Duration = Duration::from_secs(5);

pub(crate) struct LogPrinter {
    tasks: Vec<JoinHandle<()>>,
}

impl Drop for LogPrinter {
    fn drop(&mut self) {
        for task in self.tasks.drain(..).rev() {
            println!("Finalizing LogPrinter");
            let result = futures::executor::block_on(
                tokio::time::timeout(DRAIN_LOGS_TIMEOUT, task));
            println!("Finalized LogPrinter {:?}", result);
        }
    }
}

impl LogPrinter {
    pub(crate) fn new() -> Self {
        Self {
            tasks: vec![],
        }
    }

    pub(crate) fn print(&mut self, log_stream: Fuse<(impl Stream<Item=String> + Unpin + Sized + Send + 'static)>) {
        let mut s = log_stream;
        let handle = tokio::spawn(async move {
            while select! {
                msg = s.next() => match msg {
                    Some(msg) => {
                        let msg: String = msg;
                        println!("{}", msg);
                        true
                    },
                    None => false
                },
            } {}
        });
        self.tasks.push(handle);
    }
}

我是这样用的

let mut log_printer: LogPrinter = LogPrinter::new();
let logs_skrouterd: impl Stream<Item=String> = stream_container_logs(&docker, "skrouterd", &skrouterd);

log_printer.print(logs_skrouterd.fuse());

当log_printer超出范围时，drop将被执行。