深入浅出 Rust 并发：RwLock 与 Mutex 在 Tauri 项目中的实践

// ... existing code ...use tokio::sync::RwLock; // 引入 Tokio 的异步 RwLock// ... existing code ...pub struct FeaturesAPIImpl {    // ApplicationContext 被 Arc 和 RwLock 包裹，以便在异步任务间安全共享和并发访问
    context: Arc<RwLock<ApplicationContext>>,
    scrap_provider: ScrapProviderEnums,
    article_recorder_service: ArticleRecorderService,
}impl FeaturesAPIImpl {    pub async fn new(ctx: ApplicationContext) -> anyhow::Result<Self> {        // ... 初始化代码 ...
        let context = Arc::new(RwLock::new(ctx)); // 创建 RwLock 实例
        // ...
        Ok(FeaturesAPIImpl {
            context,
            scrap_provider,
            article_recorder_service,
        })
    }    // 示例：读取配置 (读操作)
    async fn update_feed_contents<R: Runtime>(
        &self,
        package_id: &str,
        feed_id: &str,
        app_handle: Option<AppHandle<R>>,
    ) -> anyhow::Result<()> {        let user_config;        let llm_section;
        {            // 获取读锁，允许多个任务同时读取 context
            let context_guarded = self.context.read().await;
            user_config = context_guarded.user_config.clone();
            llm_section = context_guarded.app_config.llm.clone();
        } // 读锁在此处释放
        // ... 后续逻辑使用 user_config 和 llm_section ...
        Ok(())
    }    // 示例：修改用户配置 (写操作)
    async fn add_feeds_package(&self, feeds_package: FeedsPackage) -> anyhow::Result<()> {        // 获取写锁，独占访问 context
        let context_guarded = &mut self.context.write().await;        let user_config = &mut context_guarded.user_config;        if user_config.add_feeds_packages(feeds_package) {            return self.sync_user_profile(user_config).await;
        }        // ...
        Err(anyhow::Error::msg(            "add_feeds_package failure, may be the feeds package already existed",
        ))        // 写锁在此处释放
    }
}

context: Arc<RwLock<ApplicationContext>> 使得  ApplicationContext 可以在多个异步的 API 请求处理任务之间安全地共享。当一个任务需要读取配置，它会调用  self.context.read().await 来获取一个读锁。多个任务可以同时持有读锁并访问  ApplicationContext。当一个任务需要修改配置，它会调用  self.context.write().await 来获取一个写锁。此时，其他任何尝试获取读锁或写锁的任务都会被阻塞，直到写锁被释放。这种机制极大地提高了读取密集型操作的并发性能，同时保证了写操作的原子性和数据一致性。

// ... existing code ...// 在插件初始化时，创建 FeaturesAPIImpl 实例并放入 Arc 中// 然后通过 app_handle.manage() 交给 Tauri 的状态管理器.setup(|app_handle, _plugin| {    let features_api = tauri::async_runtime::block_on(async {        let context_host = Startup::launch().await.unwrap();        let context = context_host.copy_context();
        FeaturesAPIImpl::new(context).await.expect("tauri-plugin-feed-api setup the features instance failure")
    });
    app_handle.manage(Arc::new(HybridRuntimeState { features_api })); // features_api 内部有 RwLock
    Ok(())
})// ... existing code ...

// ... existing code ...// Tauri 命令通过 State 获取共享的 HybridRuntimeState#[tauri::command(rename_all = "snake_case")]pub(crate) async fn get_feeds_packages(
    state: State<'_, Arc<HybridRuntimeState>>,
) -> Result<Vec<FeedsPackage>, ()> {    // features_api 内部的 RwLock 会在这里发挥作用
    let features_api = &state.features_api;    Ok(features_api.get_feeds_packages().await)
}// ... existing code ...

总结与展望

Mutex 和  RwLock 是 Rust 并发编程中不可或缺的同步原语。它们以不同的策略平衡了数据安全和并发性能的需求。在 Saga Reader 项目中，我们根据具体的业务场景和数据访问模式，恰当地选择了  Mutex 来保证资源操作的串行化，以及  RwLock 来优化共享配置的并发读取性能。