主页 / coding / 问题 / 79528576
Accepted
Dolphin
Asked: 2025-03-23 15:02:48 +0800 CST

在 Rust 中阻止同步函数中调用异步代码

  • 772

我想在 rust 中调用 http rpc，但当前上下文是同步的。然后我尝试像这样调用远程 rpc：

 let uniq_id = executor::block_on(get_snowflake_id());

这是get_snowflake_id功能：

use std::env;
use log::error;
use reqwest::Client;
use rust_wheel::model::response::api_response::ApiResponse;

pub async fn get_snowflake_id() -> Option<i64> {
    let client = Client::new();
    let infra_url = env::var("INFRA_URL").expect("INFRA_URL must be set");
    let url = format!("{}{}", infra_url, "/infra-inner/util/uniqid/gen");
    let resp = client
        .get(format!("{}", url))
        .body("{}")
        .send()
        .await;
    if let Err(e) = resp {
        error!("get id failed: {}", e);
        return None;
    }
    let text_response = resp.unwrap().text().await;
    if let Err(e) = text_response {
        error!("extract text failed: {}", e);
        return None;
    }
    let resp_str = text_response.unwrap_or_default();
    let resp_result = serde_json::from_str::<ApiResponse<i64>>(&resp_str);
    if let Err(pe) = resp_result {
        error!("parse failed: {}, response: {}", pe, &resp_str);
        return None;
    }
    Some(resp_result.unwrap().result)
}

但此代码被永久阻止，我在同步上下文中调用异步代码的方法是否正确？我必须这样做，因为上下文是同步的，我无法将当前上下文调用样式更改为异步。我试过：

pub fn get_uniq_id() -> Option<i64> {
    task::block_in_place(|| {
        tokio::runtime::Handle::current().block_on(get_snowflake_id())
    })
}

显示错误 can call blocking only when running on the multi-threaded runtime。这是应用程序入口：

#[actix_web::main]
async fn main() -> std::io::Result<()> {}
rust

1 个回答

  1. Best Answer

    如果您的应用程序准备使用 Tokio，您应该使用 Tokio 提供的专用阻塞调用：

    use tokio::runtime::Runtime;

fn invoke_sync() -> Option<i64> {
    let rt = Runtime::new().unwrap();
    rt.block_on(get_snowflake_id())
}

    use tokio::runtime::Runtime;
use once_cell::sync::Lazy;

static TOKIO_RT: Lazy<Runtime> = Lazy::new(|| {
    Runtime::new().expect("Failed to create Tokio runtime")
});

fn invoke_sync() -> Option<i64> {
    TOKIO_RT.block_on(get_snowflake_id())
}

    如果您的应用程序在 Tokio 运行时中运行，则应该使用 Tokio 的专用阻止机制：

    use tokio::task;

fn invoke_sync() -> Option<i64> {
    task::block_in_place(|| {
        // This is safe if you're already within a Tokio runtime
        tokio::runtime::Handle::current().block_on(get_snowflake_id())
    })
}

    使用 tokio::task::block_in_place + Handle::current().block_on(...)

    Tokio 运行时之外（纯同步）：

    创建并重用全局运行时(tokio::runtime::Runtime)和call .block_on(...).

    仅供参考：Docs-Tokio

    • 1

相关问题