我已经决定了一种方法，我创建了一个时雄Runtime，然后将其传递给每个包含异步代码的FFI函数调用：

use std::os::raw::c_char;
use std::ffi::{CString, CStr};
use sn_api::{BootstrapConfig, Safe};
use tokio::runtime::Runtime;
#[no_mangle]
pub extern "C" fn init_runtime() -> *mut Runtime {
    Box::into_raw(Box::new(Runtime::new().unwrap()))
}
#[no_mangle]
pub extern "C" _safe_connect(rt_ptr: *mut Runtime, safe_ptr: *mut Safe, bootstrap_contact: *const c_char) {
    assert!(!safe_ptr.is_null());
    assert!(!rt_ptr.is_null());
    let bootstrap_contact = unsafe {
        CStr::from_ptr(bootstrap_contact)
    }
    let mut bootstrap_contacts = BootstrapConfig::default();
    bootstrap_contacts.insert(bootstrap_contact.parse().expect("Invalid bootstrap address"));
    unsafe {
        let _safe = &mut *safe_ptr;
        let rt = &mut *rt_ptr;
        rt.block_on(_safe.connect(None, None, Some(bootstrap_contacts))).unwrap();
    }
}

使用静态变量保持运行库对函数调用的可访问性。

use once_cell::sync::Lazy;
use tokio::runtime::{self, Runtime};
static RUNTIME: Lazy<Runtime> = Lazy::new(|| {
    runtime::Builder::new_multi_thread()
        .enable_io()
        .build()
        .unwrap()
});

我也面临着同样的问题。这是我的削减：export-tokio-to-lib。

plugin.rs:

use async_ffi::{FfiFuture, FutureExt};
use tokio::runtime::Handle;
/// # Safety
#[no_mangle]
pub unsafe extern "C" fn test(arg: f32, handle: *const Handle) -> FfiFuture<safer_ffi::String> {
    let handle = &*handle;
    async move {
        let _enter = handle.enter();
        tokio::time::sleep(std::time::Duration::from_secs_f32(arg)).await;
        format!("slept {arg} secs").into()
    }
    .into_ffi()
}

试试这个
由此：

#[tokio::main]
async fn main() {
    println!("hello");
}

转化为：

fn main() {
    let mut rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(async {
        println!("hello");
    })
}

参考：https://tokio.rs/tokio/tutorial/hello-tokio#async-main-function