Rust异步运行时共享库tokio-shared-rt的使用指南

介绍

tokio-shared-rt是一个Rust库，它允许在多个任务或线程之间高效共享Tokio运行时实例。在需要跨多个组件或模块使用同一个Tokio运行时的场景下，这个库特别有用，避免了创建多个运行时实例带来的性能开销。

主要特性

• 提供线程安全的Tokio运行时共享机制
• 支持多线程环境下的运行时共享
• 简化异步代码中运行时的管理
• 兼容Tokio的各种功能特性

使用方法

基本安装

首先在Cargo.toml中添加依赖：

[dependencies]
tokio-shared-rt = "0.1"
tokio = { version = "1.0", features = ["full"] }

基本使用示例

use tokio_shared_rt::SharedRuntime;

#[tokio::main]
async fn main() {
    // 创建共享运行时
    let shared_rt = SharedRuntime::new();
    
    // 获取运行时引用
    let rt = shared_rt.get();
    
    // 使用运行时生成异步任务
    rt.spawn(async {
        println!("Task running on shared runtime");
    });
    
    // 等待任务完成
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}

多线程共享示例

use std::sync::Arc;
use tokio_shared_rt::SharedRuntime;

#[tokio::main]
async fn main() {
    let shared_rt = Arc::new(SharedRuntime::new());
    
    let handles: Vec<_> = (0..4).map(|i| {
        let rt = shared_rt.clone();
        std::thread::spawn(move || {
            let rt = rt.get();
            rt.block_on(async {
                println!("Thread {} executing async task", i);
                tokio::time::sleep(std::time::Duration::from_millis(100)).await;
                println!("Thread {} finished", i);
            });
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
}

与结构体结合使用

use tokio_shared_rt::SharedRuntime;

struct AsyncService {
    rt: SharedRuntime,
}

impl AsyncService {
    fn new() -> Self {
        Self {
            rt: SharedRuntime::new(),
        }
    }
    
    async fn perform_task(&self) {
        self.rt.get().spawn(async {
            println!("Performing background task");
        });
    }
}

#[tokio::main]
async fn main() {
    let service = AsyncService::new();
    service.perform_task().await;
    tokio::time::sleep(std::time::Duration::from_secs(1)).await;
}

高级用法

自定义运行时配置

use tokio_shared_rt::SharedRuntime;
use tokio::runtime::Builder;

let rt = Builder::new_multi_thread()
    .worker_threads(4)
    .enable_all()
    .build()
    .unwrap();

let shared_rt = SharedRuntime::from(rt);

跨模块共享

// 在lib.rs或main.rs中
pub static SHARED_RT: Lazy<SharedRuntime> = Lazy::new(SharedRuntime::new);

// 在其他模块中使用
use crate::SHARED_RT;

async fn some_function() {
    SHARED_RT.get().spawn(async {
        // 任务代码
    });
}

完整示例demo

下面是一个结合多个特性的完整示例：

use std::sync::Arc;
use tokio::time::{sleep, Duration};
use tokio_shared_rt::SharedRuntime;
use once_cell::sync::Lazy;

// 全局共享运行时
pub static GLOBAL_RT: Lazy<Arc<SharedRuntime>> = Lazy::new(|| {
    Arc::new(SharedRuntime::new())
});

struct TaskRunner {
    rt: Arc<SharedRuntime>,
    id: u32,
}

impl TaskRunner {
    fn new(id: u32) -> Self {
        Self {
            rt: GLOBAL_RT.clone(),
            id,
        }
    }

    async fn run(&self) {
        let rt = self.rt.get();
        rt.spawn(async move {
            println!("Task {} started", self.id);
            sleep(Duration::from_millis(200)).await;
            println!("Task {} completed", self.id);
        });
    }
}

#[tokio::main]
async fn main() {
    // 创建多个任务运行器
    let runners: Vec<_> = (0..5).map(|i| TaskRunner::new(i)).collect();
    
    // 并行运行所有任务
    let tasks: Vec<_> = runners.iter().map(|r| r.run()).collect();
    futures::future::join_all(tasks).await;
    
    // 等待所有任务完成
    sleep(Duration::from_secs(1)).await;
}

注意事项

1. 确保不要在不同的线程中创建多个SharedRuntime实例，除非确实需要多个运行时
2. 在大多数情况下，应用程序应该只有一个共享的Tokio运行时实例
3. 使用Arc<SharedRuntime>来跨线程共享运行时引用
4. 注意运行时的生命周期管理，避免在运行时被丢弃后继续使用

tokio-shared-rt简化了Tokio运行时在复杂应用中的管理，特别是在需要跨多个组件或线程共享运行时的场景下，能够显著提高代码的整洁性和性能。