@@ -54,9 +54,9 @@ corosio::io_context ioc;
 
 Creates an `io_context` with a concurrency hint of
 `std::max(1u, std::thread::hardware_concurrency())`. The concurrency hint only
-tunes performance and never changes the safety contract; single-threaded
-(lockless) mode is opt-in exclusively via the `single_threaded_lockless` option
-(see xref:4.guide/4c2.configuration.adoc#single-threaded-mode[Single-Threaded Mode]).
+tunes performance and never changes the safety contract; lockless modes are
+opt-in exclusively via the `locking` option
+(see xref:4.guide/4c2.configuration.adoc#single-threaded-mode[Locking Tiers]).
 
 === With Concurrency Hint
 
@@ -75,9 +75,10 @@ The concurrency hint affects:
   from `thread_pool_size`.
 
 The hint never disables locking — a context built with `concurrency_hint == 1`
-remains fully thread-safe, so other threads may `post()` into it. To drop
-synchronization overhead in a genuinely single-threaded program, set
-`io_context_options::single_threaded_lockless = true` instead.
+remains fully thread-safe, so other threads may `post()` into it (a hint of `1`
+does enable a single-run-thread wakeup fast path, with locks still on). To drop
+synchronization overhead in a genuinely single-threaded program, set the
+`io_context_options::locking` tier instead.
 
 == Running the Event Loop
 
@@ -266,9 +267,10 @@ for (auto& t : threads)
 ----
 
 Multiple threads can call `run()` concurrently. The `io_context` distributes
-work across threads. The one exception is lockless mode: constructing with
-`io_context_options::single_threaded_lockless = true` drops these guarantees (see
-xref:4.guide/4c2.configuration.adoc#single-threaded-mode[Single-Threaded Mode]).
+work across threads. The one exception is a lockless `locking` tier: constructing
+with `io_context_options::locking` set to `unsafe_io` or `unsafe` drops these
+guarantees (see
+xref:4.guide/4c2.configuration.adoc#single-threaded-mode[Locking Tiers]).
 
 WARNING: Individual I/O objects (sockets, timers) are not thread-safe.
 Don't access the same socket from multiple threads without synchronization.
 
@@ -80,14 +80,14 @@ corosio::native_io_context<corosio::epoll> ioc(opts);
   blocking file I/O and DNS resolution.  Ignored on IOCP where
   file I/O uses native overlapped I/O.
 
-| `single_threaded_lockless`
-| false
+| `locking`
+| `locking_mode::safe`
 | all
-| Disable all scheduler mutex and condition variable operations.
-  Eliminates synchronization overhead when only one thread calls
-  `run()`.  The only way to enable lockless mode; the concurrency
-  hint never disables locking.  See <<single-threaded-mode>> for
-  restrictions.
+| Locking-safety tier: `safe` (default, full thread safety),
+  `unsafe_io` (per-descriptor I/O locks off), or `unsafe` (all locks
+  off).  The only way to enable lockless behavior; the concurrency
+  hint never disables locking.  See <<single-threaded-mode>> for the
+  tiers and their restrictions.
 |===
 
 Options that do not apply to the active backend are silently ignored.
@@ -146,36 +146,75 @@ and DNS resolution use a shared thread pool.
 * *No file I/O*: leave at 1 (the pool is created lazily).
 
 [#single-threaded-mode]
-=== Single-Threaded Mode (`single_threaded_lockless`)
+=== Locking Tiers (`locking`)
 
-Disables all mutex and condition variable operations inside the
-scheduler and per-socket descriptor states.  This eliminates
-15-25% of overhead on the post-and-dispatch hot path.
+The `locking` option selects which internal locks the scheduler and
+reactor elide, trading thread-safety guarantees for reduced
+synchronization overhead.  It is the *only* way to enable lockless
+behavior — the `concurrency_hint` passed at construction never disables
+locking (see <<concurrency-hint-and-locking>>).
 
-Setting `single_threaded_lockless = true` is the *only* way to enable
-lockless mode.  The `concurrency_hint` passed at construction never
-disables locking — in particular, `concurrency_hint == 1` keeps the
-context fully thread-safe (unlike some other libraries, where a hint
-of `1` silently elides synchronization).  Enabling this option
-transfers responsibility for the restrictions below to the caller.
+[cols="1,3"]
+|===
+| Tier | Behavior
+
+| `locking_mode::safe` (default)
+| Full thread safety.  All locks enabled; any thread may use the
+  context.
+
+| `locking_mode::unsafe_io`
+| Disables only the per-descriptor I/O locks; scheduler locking stays
+  on.  A single thread must run and drive the context, but DNS
+  resolution and POSIX file I/O remain available (they rely on
+  scheduler locking).
+
+| `locking_mode::unsafe`
+| Disables all locking.  Eliminates 15-25% of overhead on the
+  post-and-dispatch hot path.  Imposes the full restrictions below.
+|===
 
 [source,cpp]
 ----
 corosio::io_context_options opts;
-opts.single_threaded_lockless = true;
+opts.locking = corosio::locking_mode::unsafe;
 
 corosio::io_context ioc(opts);
 ioc.run();  // only one thread may call this
 ----
 
-WARNING: Single-threaded mode imposes hard restrictions.
+WARNING: The `unsafe` and `unsafe_io` tiers impose hard restrictions.
 Violating them is undefined behavior.
 
 * Only **one thread** may call `run()` (or any run/poll variant).
 * **Posting work from another thread** is undefined behavior.
-* **DNS resolution** returns `operation_not_supported`.
-* **POSIX file I/O** (`stream_file`, `random_access_file`) returns
-  `operation_not_supported` on `open()`.
 * **Signal sets** should not be shared across contexts.
 * **Timer cancellation via `stop_token`** from another thread
   remains safe (the timer service retains its own mutex).
+
+The `unsafe` tier additionally makes:
+
+* **DNS resolution** return `operation_not_supported`.
+* **POSIX file I/O** (`stream_file`, `random_access_file`) return
+  `operation_not_supported` on `open()`.
+
+These two services stay available under `unsafe_io` because they rely
+on scheduler locking, which that tier keeps enabled.
+
+[NOTE]
+====
+These tiers mirror Boost.Asio's `SAFE` / `UNSAFE_IO` / `UNSAFE`
+concurrency-hint constants.  corosio exposes them as an option rather
+than folding them into the hint, keeping the safety contract separate
+from the performance knob.
+====
+
+[#concurrency-hint-and-locking]
+==== The concurrency hint is orthogonal
+
+The `concurrency_hint` constructor argument only tunes performance and
+never changes the safety contract.  In particular, `concurrency_hint ==
+1` keeps the context fully thread-safe — unlike some other libraries,
+where a hint of `1` silently elides synchronization.  A hint of `1`
+does enable a single-run-thread fast path (eliding inter-run-thread
+wakeups) while keeping all locks on, so cross-thread `post()` remains
+safe.
@@ -360,9 +360,8 @@ struct iocp_t
         @param ctx The execution context that owns the scheduler.
         @param concurrency_hint Hint for the number of threads that
             will call `run()`. Only tunes performance; it never
-            changes the safety contract. Single-threaded (lockless)
-            mode is opt-in exclusively via
-            @ref io_context_options::single_threaded_lockless.
+            changes the safety contract. Lockless modes are opt-in
+            exclusively via @ref io_context_options::locking.
 
         @return Reference to the newly created scheduler.
     */
 
@@ -97,13 +97,38 @@ struct BOOST_COROSIO_DECL scheduler
     */
     virtual void register_signal_reader(int read_fd) { (void)read_fd; }
 
-    /// True if the scheduler is configured for single-threaded use.
-    /// Default false; overridden by backends that support the mode.
-    virtual bool is_single_threaded() const noexcept { return false; }
-
-    /// Enable or disable single-threaded mode. Default no-op for
-    /// backends that don't support the mode.
-    virtual void configure_single_threaded(bool) noexcept {}
+    /** Decomposed threading configuration for a scheduler.
+
+        Mirrors the orthogonal locking facilities Boost.Asio derives from
+        its concurrency hint, plus the single-run-thread optimization flag:
+
+        @li @ref scheduler_locking — the scheduler's own mutex/condvar (and,
+            where a backend folds registration into it, the descriptor table).
+            Disabled only in the fully-lockless (`unsafe`) tier.
+        @li @ref reactor_io_locking — the per-descriptor state mutex taken on
+            the I/O completion fast path (reactors), or the ring mutex
+            (io_uring). Disabled in both the `unsafe_io` and `unsafe` tiers.
+        @li @ref one_thread — enables the single-run-thread fast path: elide
+            inter-run-thread wakeups. Locks are unaffected; this stays safe for
+            cross-thread `post()`. Set when the concurrency hint is 1 or any
+            lockless tier is selected.
+    */
+    struct threading_config
+    {
+        bool scheduler_locking  = true;
+        bool reactor_io_locking = true;
+        bool one_thread         = false;
+    };
+
+    /// True when scheduler locking is disabled (the fully-lockless tier).
+    /// Services that hand work to other threads (resolver, POSIX file I/O)
+    /// key their `operation_not_supported` restriction on this. Default
+    /// false; overridden by backends that support lockless mode.
+    virtual bool scheduler_locking_disabled() const noexcept { return false; }
+
+    /// Apply a decomposed threading configuration. Default no-op for
+    /// backends that don't support the modes.
+    virtual void configure_threading(threading_config) noexcept {}
 };
 
 } // namespace boost::corosio::detail
 
@@ -26,6 +26,42 @@
 
 namespace boost::corosio {
 
+/** Locking-safety tier for an @ref io_context.
+
+    Selects which internal locks the scheduler and reactor elide, trading
+    thread-safety guarantees for reduced synchronization overhead. This is
+    the analog of Boost.Asio's `SAFE` / `UNSAFE_IO` / `UNSAFE` concurrency
+    hint constants. The `concurrency_hint` passed at construction is a
+    separate, orthogonal performance knob and never changes the safety
+    contract.
+
+    @see io_context_options::locking
+*/
+enum class locking_mode
+{
+    /** Full thread safety (default). All locks enabled; equivalent to
+        Boost.Asio's `SAFE`/`DEFAULT`. Any thread may use the context. */
+    safe,
+
+    /** Disable only the per-descriptor I/O locks; keep scheduler locking.
+        Equivalent to Boost.Asio's `UNSAFE_IO`. The context must be run
+        and driven by a single thread, but resolver and POSIX file
+        services remain available (they rely on scheduler locking, which
+        stays on). */
+    unsafe_io,
+
+    /** Disable all locking (fully lockless). Equivalent to Boost.Asio's
+        `UNSAFE`.
+
+        @par Restrictions
+        - Only one thread may call `run()` (or any run variant).
+        - Posting work from another thread is undefined behavior.
+        - DNS resolution returns `operation_not_supported`.
+        - POSIX file I/O returns `operation_not_supported`.
+        - Signal sets should not be shared across contexts. */
+    unsafe
+};
+
 /** Runtime tuning options for @ref io_context.
 
     All fields have defaults that match the library's built-in
@@ -97,33 +133,21 @@ struct io_context_options
     */
     unsigned thread_pool_size = 1;
 
-    /** Enable single-threaded, lockless mode (disable scheduler locking).
-
-        When true, the scheduler skips all mutex lock/unlock and
-        condition variable operations on the hot path. This
-        eliminates synchronization overhead when only one thread
-        calls `run()`.
+    /** Locking-safety tier (thread-safety vs. lock elision).
 
-        Enabling this drops the io_context's thread-safety guarantees:
-        the caller takes on responsibility for the restrictions below.
-        Leaving it `false` (the default) keeps the context fully
-        thread-safe.
-
-        @par Restrictions
-        - Only one thread may call `run()` (or any run variant).
-        - Posting work from another thread is undefined behavior.
-        - DNS resolution returns `operation_not_supported`.
-        - POSIX file I/O returns `operation_not_supported`.
-        - Signal sets should not be shared across contexts.
+        Selects which internal locks are elided. The default,
+        @ref locking_mode::safe, keeps full thread safety. The
+        `unsafe_io` and `unsafe` tiers drop locks in exchange for lower
+        overhead and impose the restrictions documented on
+        @ref locking_mode.
 
-        @note This field is the *only* way to enable lockless mode. The
-            `concurrency_hint` passed at construction never changes the
-            safety contract — it only tunes performance. In particular,
-            `concurrency_hint == 1` keeps full thread safety (unlike
-            asio's named `ASIO_CONCURRENCY_HINT_UNSAFE` constants, which
-            this field mirrors).
+        This is the *only* way to enable lockless behavior. The
+        `concurrency_hint` passed at construction never changes the
+        safety contract — it only tunes performance (e.g. the
+        single-run-thread wakeup fast path when `concurrency_hint == 1`,
+        and, on IOCP, the completion-port concurrency).
     */
-    bool single_threaded_lockless = false;
+    locking_mode locking = locking_mode::safe;
 
     /** Enable IORING_SETUP_SQPOLL on the io_uring backend.
 
@@ -133,7 +157,7 @@ struct io_context_options
         path. Most useful for sustained traffic. Idle thread parks
         after `sq_thread_idle_ms` of no activity.
 
-        Independent of `single_threaded_lockless`. Default: off.
+        Independent of `locking`. Default: off.
 
         Ignored on non-io_uring backends.
     */
@@ -203,9 +227,9 @@ class timer_service;
 
     @par Thread Safety
     Distinct objects: Safe.@n
-    Shared objects: Safe, unless the context was constructed with
-    `io_context_options::single_threaded_lockless = true` (lockless
-    mode), in which case only one thread may use it. The
+    Shared objects: Safe, unless the context was constructed with a
+    lockless @ref io_context_options::locking tier (`unsafe_io` or
+    `unsafe`), in which case a single thread must drive it. The
     `concurrency_hint` does not affect thread safety.
 
     @see epoll_t, select_t, kqueue_t, iocp_t
@@ -220,6 +244,15 @@ class BOOST_COROSIO_DECL io_context : public capy::execution_context
         io_context_options const& opts,
         unsigned concurrency_hint);
 
+    /** Apply only the decomposed threading configuration (locking tiers +
+        one-thread fast path). Used by the plain constructors, which — unlike
+        the options constructors — deliberately leave the reactor budget at
+        its defaults rather than engaging the multi-thread post-everything
+        heuristic. */
+    void apply_threading_(
+        io_context_options const& opts,
+        unsigned concurrency_hint);
+
 protected:
     detail::scheduler* sched_;
 
@@ -231,9 +264,8 @@ class BOOST_COROSIO_DECL io_context : public capy::execution_context
 
         Uses `std::thread::hardware_concurrency()` (floored to 1, in
         case it reports 0) as the concurrency hint. The hint only tunes
-        performance and never affects thread safety; single-threaded
-        (lockless) mode is opt-in exclusively via
-        @ref io_context_options::single_threaded_lockless.
+        performance and never affects thread safety; lockless modes are
+        opt-in exclusively via @ref io_context_options::locking.
     */
     io_context();
 
@@ -272,6 +304,10 @@ class BOOST_COROSIO_DECL io_context : public capy::execution_context
     {
         (void)backend;
         sched_ = &Backend::construct(*this, concurrency_hint);
+        // Apply threading config only (one-thread fast path for
+        // concurrency_hint == 1, locking tier). Unlike the options ctor,
+        // the plain path leaves the reactor budget at its defaults.
+        apply_threading_(io_context_options{}, concurrency_hint);
     }
 
     /** Construct with an explicit backend tag and runtime options.
 
@@ -265,7 +265,7 @@ epoll_scheduler::register_descriptor(int fd, reactor_descriptor_state* desc) con
     desc->registered_events = ev.events;
     desc->fd                = fd;
     desc->scheduler_        = this;
-    desc->mutex.set_enabled(!single_threaded_);
+    desc->mutex.set_enabled(reactor_io_locking_);
     desc->ready_events_.store(0, std::memory_order_relaxed);
 
     conditionally_enabled_mutex::scoped_lock lock(desc->mutex);