async_runtime: remove thread_local of Runtime

If put Runtime into thread_local, the order of Drop calls is
platform-dependent. This will case panic in the `tokio-uring`
Runtime Drop function.
The pr tokio-rs/tokio-uring#173 will fix.
We will revert this, if it is meraged.

Signed-off-by: wanglei01 <[email protected]>

Author: wllenyj

src/common/async_runtime.rs

@@ -49,6 +49,27 @@ impl Runtime {
             Runtime::Uring(rt) => rt.lock().unwrap().block_on(f),
         }
     }
+
+    /// Spawns a new asynchronous task, returning a [`JoinHandle`] for it.
+    ///
+    /// Spawning a task enables the task to execute concurrently to other tasks.
+    /// There is no guarantee that a spawned task will execute to completion. When a
+    /// runtime is shutdown, all outstanding tasks are dropped, regardless of the
+    /// lifecycle of that task.
+    ///
+    /// This function must be called from the context of a `tokio-uring` runtime.
+    ///
+    /// [`JoinHandle`]: tokio::task::JoinHandle
+    pub fn spawn<T: std::future::Future + 'static>(
+        &self,
+        task: T,
+    ) -> tokio::task::JoinHandle<T::Output> {
+        match self {
+            Runtime::Tokio(_) => tokio::task::spawn_local(task),
+            #[cfg(target_os = "linux")]
+            Runtime::Uring(_) => tokio_uring::spawn(task),
+        }
+    }
 }
 
 /// Start an async runtime.
@@ -62,39 +83,33 @@ impl Default for Runtime {
     }
 }
 
-std::thread_local! {
-    pub(crate) static CURRENT_RUNTIME: Runtime = Runtime::new();
-}
-
 /// Run a callback with the default `Runtime` object.
 pub fn with_runtime<F, R>(f: F) -> R
 where
     F: FnOnce(&Runtime) -> R,
 {
-    CURRENT_RUNTIME.with(f)
+    let rt = Runtime::new();
+    f(&rt)
 }
 
 /// Run a future to completion with the default `Runtime` object.
 pub fn block_on<F: Future>(f: F) -> F::Output {
-    CURRENT_RUNTIME.with(|rt| rt.block_on(f))
+    Runtime::new().block_on(f)
 }
 
-/// Spawns a new asynchronous task, returning a [`JoinHandle`] for it.
+/// Spawns a new asynchronous task with the defualt `Runtime`, returning a [`JoinHandle`] for it.
 ///
 /// Spawning a task enables the task to execute concurrently to other tasks.
 /// There is no guarantee that a spawned task will execute to completion. When a
 /// runtime is shutdown, all outstanding tasks are dropped, regardless of the
 /// lifecycle of that task.
 ///
-/// This function must be called from the context of a `tokio-uring` runtime.
+/// This will create a new Runtime to run spawn.
 ///
 /// [`JoinHandle`]: tokio::task::JoinHandle
 pub fn spawn<T: std::future::Future + 'static>(task: T) -> tokio::task::JoinHandle<T::Output> {
-    CURRENT_RUNTIME.with(|rt| match rt {
-        Runtime::Tokio(_) => tokio::task::spawn_local(task),
-        #[cfg(target_os = "linux")]
-        Runtime::Uring(_) => tokio_uring::spawn(task),
-    })
+    let rt = Runtime::new();
+    rt.spawn(task)
 }
 
 #[cfg(test)]