Rust中如何启动多服务/进程并在收到SIGINT/SIGTERM时优雅关闭

核心问题梳理 #

你遇到的编译报错和逻辑问题本质是两个原因：

1. 所有权冲突：你尝试让启动future、停止future同时持有Application实例的引用，Rust编译器无法证明两个future的生命周期一定短于Application本身的生命周期，和Go不同，Rust没有GC自动处理跨异步单元的生命周期，需要你主动标记所有权共享。
2. 同步逻辑阻塞异步执行器：你用了signal_hook的同步迭代器，放在async块中会阻塞整个执行器的调度，类似你在Go的goroutine里写死循环不让出调度，会卡住其他goroutine执行。

修改步骤 #

1. 调整trait约束 #

首先给IAdapter trait增加Send和'static约束，确保实现了该trait的实例可以跨线程安全传递，适配多线程异步执行器，类比Go中要求传入goroutine的变量是并发安全的。

/// IAdapter represents an Application process.
pub trait IAdapter: Send + 'static {
    /// name provides the name of the Adapter.
    fn name(&self) -> String;
    /// start starts the adapter.
    fn start(&self) -> PinFuture<OptionBoxErr>;
    /// stop stops the adapter.
    fn stop(&self) -> PinFuture<OptionBoxErr>;
}

对应的类型别名也加上Send约束，确保future可以跨线程调度：

/// PinFuture<T> is essentially Future<Output = T>
pub type PinFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;

// OptionBoxErr is essentially Option<Error>
pub type OptionBoxErr = Option<Box<dyn Error + Send + Sync>>;

2. 实现Application的并发启动/停止逻辑 #

用futures::future::join_all实现并发调用所有adapter的方法，类比Go中开多个goroutine执行方法，再用sync.WaitGroup等待所有执行完成。

use futures::future::join_all;

impl Application {
    /// start method launches the Application by starting all the adapters.
    async fn start(&self) {
        // 收集所有adapter的start future
        let start_futures = self.adapters.iter().map(|adapter| async move {
            if let Some(e) = adapter.start().await {
                eprintln!("Adapter {} start failed: {:?}", adapter.name(), e);
            }
        });
        // 并发等待所有启动完成
        join_all(start_futures).await;
        println!("All adapters started successfully");
    }

    /// stop method stops the Application by stopping all the adapters.
    async fn stop(&self) {
        let stop_futures = self.adapters.iter().map(|adapter| async move {
            if let Some(e) = adapter.stop().await {
                eprintln!("Adapter {} stop failed: {:?}", adapter.name(), e);
            }
        });
        join_all(stop_futures).await;
        println!("All adapters stopped successfully");
    }
}

3. 修复main函数的所有权与逻辑问题 #

用Arc包裹Application实现多所有权共享，类比Go中把同一个实例传给多个goroutine使用，Arc的引用计数会自动管理实例生命周期；同时改用异步信号监听避免阻塞执行器。

use std::sync::Arc;
use futures::executor::block_on;
use futures::future::select;
use signal_hook::consts::{SIGINT, SIGTERM};
use signal_hook_async_std::Signals; // 也可以用tokio的信号实现，逻辑一致

fn main() {
    // 用Arc包裹Application实现多所有权共享
    let application = Arc::new(Application {
        adapters: vec![
            // 这里放你实现的HTTP服务、定时任务实例
        ],
    });

    // 克隆Arc给启动future用
    let app_for_start = application.clone();
    let start_future = Box::pin(async move {
        app_for_start.start().await;
        // 启动完成后就一直挂起，等待停止信号
        std::future::pending::<()>().await;
    });

    // 克隆Arc给停止future用
    let app_for_stop = application.clone();
    let stop_future = Box::pin(async move {
        println!("Attaching signal listener.");
        let mut signals = Signals::new(&[SIGINT, SIGTERM]).unwrap();
        // 异步等待信号到来，不会阻塞执行器
        signals.next().await;

        println!("Shutting down the Application...");
        app_for_stop.stop().await;
    });

    // 等待两个future任意一个完成就退出
    block_on(async {
        select(start_future, stop_future).await;
    });
}

额外说明 #

• 如果你用tokio作为运行时，只需要把信号监听换成tokio::signal::ctrl_c()，执行器换成tokio::main宏即可，逻辑完全一致
• 如果你的IAdapter实现内部有可变状态，只需要把可变字段用Mutex或者RwLock包裹即可，类比Go里用sync.Mutex保护共享变量

内容的提问来源于stack exchange，提问作者Shivansh Kuchhal