feat & refactor(!): Change Default Blocking Handle Behavior & Add Basic Read Op

.github/workflows/ci.sh

@@ -26,6 +26,10 @@ if [ "${NO_RUN}" != "1" ] && [ "${NO_RUN}" != "true" ]; then
     "${CARGO}" test --target "${TARGET}" --no-default-features --features "async-cancel,bytes,legacy,macros,utils"
     "${CARGO}" test --target "${TARGET}" --no-default-features --features "async-cancel,bytes,legacy,macros,utils" --release
 
+    # enable legacy and sync
+    "${CARGO}" test --target "${TARGET}" --no-default-features --features "async-cancel,bytes,legacy,macros,utils,sync"
+    "${CARGO}" test --target "${TARGET}" --no-default-features --features "async-cancel,bytes,legacy,macros,utils,sync" --release
+
     if [ "${TARGET}" = "x86_64-unknown-linux-gnu" ] || [ "${TARGET}" = "i686-unknown-linux-gnu" ]; then
         # only enabled uring driver
         "${CARGO}" test --target "${TARGET}" --no-default-features --features "async-cancel,bytes,iouring,macros,utils"

monoio/Cargo.toml

@@ -44,7 +44,7 @@ windows-sys = { version = "0.48.0", features = [
     "Win32_Networking_WinSock",
     "Win32_System_IO",
     "Win32_Storage_FileSystem",
-    "Win32_Security"
+    "Win32_Security",
 ] }
 
 # unix dependencies

monoio/src/builder.rs

@@ -32,15 +32,29 @@ pub struct RuntimeBuilder<D> {
 scoped_thread_local!(pub(crate) static BUILD_THREAD_ID: usize);
 
 impl<T> Default for RuntimeBuilder<T> {
-    /// Create a default runtime builder
+    /// Create a default runtime builder.
+    ///
+    /// # Note
+    ///
+    /// When the sync feature is enabled, the default behavior of
+    /// [monoio::blocking::BlockingStrategy] is to execute tasks on the local thread. In other
+    /// words, there is no thread pool involved—all blocking I/O operations and heavy computations
+    /// will block the current thread.
     #[must_use]
     fn default() -> Self {
         RuntimeBuilder::<T>::new()
     }
 }
 
 impl<T> RuntimeBuilder<T> {
-    /// Create a default runtime builder
+    /// Create a default runtime builder.
+    ///
+    /// # Note
+    ///
+    /// When the sync feature is enabled, the default behavior of
+    /// [monoio::blocking::BlockingStrategy] is to execute tasks on the local thread. In other
+    /// words, there is no thread pool involved—all blocking I/O operations and heavy computations
+    /// will block the current thread.
     #[must_use]
     pub fn new() -> Self {
         Self {
@@ -50,7 +64,7 @@ impl<T> RuntimeBuilder<T> {
             urb: io_uring::IoUring::builder(),
 
             #[cfg(feature = "sync")]
-            blocking_handle: crate::blocking::BlockingStrategy::Panic.into(),
+            blocking_handle: crate::blocking::BlockingStrategy::ExecuteLocal.into(),
             _mark: PhantomData,
         }
     }
@@ -148,7 +162,6 @@ impl<D> RuntimeBuilder<D> {
     /// inner `io_uring` API.
     ///
     /// Refer to the [`io_uring::Builder`] documentation for all the supported methods.
-
     #[cfg(all(target_os = "linux", feature = "iouring"))]
     #[must_use]
     pub fn uring_builder(mut self, urb: io_uring::Builder) -> Self {

monoio/src/driver/op.rs

@@ -8,17 +8,16 @@ use std::{
 use crate::driver;
 
 pub(crate) mod close;
+pub(crate) mod read;
+pub(crate) mod write;
 
 mod accept;
 mod connect;
 mod fsync;
 mod open;
 mod poll;
-mod read;
 mod recv;
 mod send;
-mod write;
-
 #[cfg(unix)]
 mod statx;