refactor: spawn and spawn_local

Author: shuai132

README.md

@@ -103,7 +103,8 @@ I have also learned about some well-known C++20 coroutine open-source libraries,
 | Name                                         | Description                                           |
 |----------------------------------------------|-------------------------------------------------------|
 | `coro::async<T>`                             | Async task type, supports `co_await` and `co_return`  |
-| `coro::co_spawn(executor, awaitable)`        | Spawn a coroutine on an executor                      |
+| `coro::spawn(executor, awaitable)`           | Spawn a coroutine on an executor                      |
+| `coro::spawn_local(awaitable)`               | Spawn a coroutine on the current executor             |
 | `coro::when_all(awaitables...) -> awaitable` | Wait for all tasks to complete                        |
 | `coro::when_any(awaitables...) -> awaitable` | Wait for any task to complete                         |
 | `coro::sleep(duration)`                      | Async wait for specified duration (chrono duration)   |
@@ -185,15 +186,20 @@ async<void> process() {
 
 int main() {
     executor_loop executor;
-    
-    // Launch coroutine
-    co_spawn(executor, process());
+
+    // Launch coroutine on specific executor
+    spawn(executor, process());
     // Or: process().detach(executor);
 
     // Run event loop
     executor.run_loop();
     return 0;
 }
+
+// Using spawn_local inside coroutine
+async<void> main_task() {
+    co_await spawn_local(process());
+}
 ```
 
 ### Launch Coroutine with Callback
@@ -536,9 +542,8 @@ async<void> consumer(channel<int>& ch) {
 async<void> example() {
     channel<int> ch;  // Unbuffered channel
 
-    auto& exec = *co_await current_executor();
-    co_spawn(exec, producer(ch));
-    co_spawn(exec, consumer(ch));
+    co_await spawn_local(producer(ch));
+    co_await spawn_local(consumer(ch));
 }
 ```
 
@@ -578,12 +583,10 @@ async<void> broadcast_example() {
         }
     };
 
-    auto& exec = *co_await current_executor();
-
     // Spawn multiple receivers
-    co_spawn(exec, receiver(ch, 1));
-    co_spawn(exec, receiver(ch, 2));
-    co_spawn(exec, receiver(ch, 3));
+    co_await spawn_local(receiver(ch, 1));
+    co_await spawn_local(receiver(ch, 2));
+    co_await spawn_local(receiver(ch, 3));
 
     // Broadcasting sends the value to ALL waiting receivers
     size_t notified_count = co_await ch.broadcast(42);
@@ -623,8 +626,8 @@ async<void> example() {
     wg.add(2);
 
     // Launch worker coroutines
-    co_spawn(executor, worker_task(wg, "Worker1", 100));
-    co_spawn(executor, worker_task(wg, "Worker2", 150));
+    spawn(executor, worker_task(wg, "Worker1", 100));
+    spawn(executor, worker_task(wg, "Worker2", 150));
 
     // Wait for all operations to complete
     co_await wg.wait();

README_CN.md

@@ -88,7 +88,8 @@
 | 名称                                           | 说明                                 |
 |----------------------------------------------|------------------------------------|
 | `coro::async<T>`                             | 异步任务类型，支持 `co_await` 和 `co_return` |
-| `coro::co_spawn(executor, awaitable)`        | 在执行器上启动协程                          |
+| `coro::spawn(executor, awaitable)`           | 在执行器上启动协程                          |
+| `coro::spawn_local(awaitable)`               | 在当前执行器上启动协程                        |
 | `coro::when_all(awaitables...) -> awaitable` | 等待所有任务完成                           |
 | `coro::when_any(awaitables...) -> awaitable` | 等待任意一个任务完成                         |
 | `coro::sleep(duration)`                      | 异步等待指定时间（chrono duration）          |
@@ -169,15 +170,20 @@ async<void> process() {
 
 int main() {
     executor_loop executor;
-    
-    // 启动协程
-    co_spawn(executor, process());
+
+    // 在指定执行器上启动协程
+    spawn(executor, process());
     // 或者: process().detach(executor);
-    
+
     // 运行事件循环
     executor.run_loop();
     return 0;
 }
+
+// 在协程内部使用 spawn_local 在当前执行器上启动协程
+async<void> main_task() {
+    co_await spawn_local(process());
+}
 ```
 
 ### 使用回调启动协程
@@ -520,9 +526,8 @@ async<void> consumer(channel<int>& ch) {
 async<void> example() {
     channel<int> ch;  // 无缓冲 channel
 
-    auto& exec = *co_await current_executor();
-    co_spawn(exec, producer(ch));
-    co_spawn(exec, consumer(ch));
+    co_await spawn_local(producer(ch));
+    co_await spawn_local(consumer(ch));
 }
 ```
 
@@ -562,12 +567,10 @@ async<void> broadcast_example() {
         }
     };
 
-    auto& exec = *co_await current_executor();
-
     // 启动多个接收者
-    co_spawn(exec, receiver(ch, 1));
-    co_spawn(exec, receiver(ch, 2));
-    co_spawn(exec, receiver(ch, 3));
+    co_await spawn_local(receiver(ch, 1));
+    co_await spawn_local(receiver(ch, 2));
+    co_await spawn_local(receiver(ch, 3));
 
     // 广播将值发送给所有等待的接收者
     size_t notified_count = co_await ch.broadcast(42);
@@ -607,8 +610,8 @@ async<void> example() {
     wg.add(2);
 
     // 启动工作协程
-    co_spawn(executor, worker_task(wg, "Worker1", 100));
-    co_spawn(executor, worker_task(wg, "Worker2", 150));
+    spawn(executor, worker_task(wg, "Worker1", 100));
+    spawn(executor, worker_task(wg, "Worker2", 150));
 
     // 等待所有操作完成
     co_await wg.wait();

include/coro/coro.hpp

@@ -220,7 +220,7 @@ struct awaitable {
   }
 
   /// co_await
-  bool await_ready() const noexcept {
+  [[nodiscard]] bool await_ready() const noexcept {
     CORO_DEBUG_LIFECYCLE("awaitable: await_ready: %p, h: %p", this, current_coro_handle_.address());
     return false;
   }
@@ -246,7 +246,7 @@ struct awaitable {
     return std::move(*this);
   }
 
-  executor* get_executor() const {
+  [[nodiscard]] executor* get_executor() const {
     return current_coro_handle_.promise().executor_;
   }
 
@@ -332,7 +332,7 @@ struct callback_awaiter : detail::callback_awaiter_base<T> {
   explicit callback_awaiter(callback_function_with_executor callback) : callback_function_(std::move(callback)) {}
   callback_awaiter(callback_awaiter&&) = default;
 
-  bool await_ready() const noexcept {
+  [[nodiscard]] bool await_ready() const noexcept {
     return false;
   }
 
@@ -382,7 +382,7 @@ struct callback_awaiter : detail::callback_awaiter_base<T> {
 namespace detail {
 
 struct current_executor_awaiter {
-  bool await_ready() const noexcept {
+  [[nodiscard]] bool await_ready() const noexcept {
     return false;
   }
 
@@ -392,7 +392,7 @@ struct current_executor_awaiter {
     return false;
   }
 
-  executor* await_resume() const noexcept {
+  [[nodiscard]] executor* await_resume() const noexcept {
     return exec_;
   }
 
@@ -402,16 +402,22 @@ struct current_executor_awaiter {
 
 }  // namespace detail
 
-detail::current_executor_awaiter current_executor() {
+[[nodiscard]] detail::current_executor_awaiter current_executor() {
   return detail::current_executor_awaiter{};
 }
 
 template <typename T>
 using async = awaitable<T>;
 
 template <typename T>
-void co_spawn(executor& executor, T&& coro) {
+void spawn(executor& executor, T&& coro) {
   coro.detach(executor);
 }
 
+template <typename T>
+[[nodiscard]] async<void> spawn_local(T&& awaitable) {
+  auto* exec = co_await current_executor();
+  spawn(*exec, std::forward<T>(awaitable));
+}
+
 }  // namespace coro

include/coro/time.hpp

@@ -3,7 +3,7 @@
 #include <chrono>
 #include <cstdint>
 
-#include "coro/coro.hpp"
+#include "coro.hpp"
 
 namespace coro {
 

test/coro_broadcast.cpp

@@ -34,12 +34,10 @@ async<void> test_broadcast_multiple_receivers() {
     co_return;
   };
 
-  auto& exec = *co_await current_executor();
-
   // Start 3 receivers
-  co_spawn(exec, receiver(1, &receiver1_value, &receiver1_done));
-  co_spawn(exec, receiver(2, &receiver2_value, &receiver2_done));
-  co_spawn(exec, receiver(3, &receiver3_value, &receiver3_done));
+  co_await spawn_local(receiver(1, &receiver1_value, &receiver1_done));
+  co_await spawn_local(receiver(2, &receiver2_value, &receiver2_done));
+  co_await spawn_local(receiver(3, &receiver3_value, &receiver3_done));
 
   // Give receivers time to start waiting
   co_await sleep(50ms);
@@ -86,11 +84,9 @@ async<void> test_broadcast_vs_send() {
     co_return;
   };
 
-  auto& exec = *co_await current_executor();
-
   // Start 2 receivers
-  co_spawn(exec, receiver(1, &receiver1_value, &receiver1_done));
-  co_spawn(exec, receiver(2, &receiver2_value, &receiver2_done));
+  co_await spawn_local(receiver(1, &receiver1_value, &receiver1_done));
+  co_await spawn_local(receiver(2, &receiver2_value, &receiver2_done));
 
   co_await sleep(50ms);
 
@@ -161,10 +157,8 @@ async<void> test_sequential_broadcasts() {
     co_return;
   };
 
-  auto& exec = *co_await current_executor();
-
-  co_spawn(exec, receiver(1, &receiver1_values));
-  co_spawn(exec, receiver(2, &receiver2_values));
+  co_await spawn_local(receiver(1, &receiver1_values));
+  co_await spawn_local(receiver(2, &receiver2_values));
 
   co_await sleep(50ms);
 

test/coro_channel.cpp

@@ -74,9 +74,8 @@ async<void> test_unbuffered_channel() {
   };
 
   // Start producer first (it should block immediately)
-  auto& exec = *co_await current_executor();
-  co_spawn(exec, tracked_producer());
-  co_spawn(exec, tracked_consumer());
+  co_await spawn_local(tracked_producer());
+  co_await spawn_local(tracked_consumer());
 
   // Allow time for operations to complete
   co_await sleep(100ms);
@@ -161,9 +160,8 @@ async<void> test_buffered_channel() {
     co_return;
   };
 
-  auto& exec = *co_await current_executor();
-  co_spawn(exec, tracked_producer());
-  co_spawn(exec, tracked_consumer());
+  co_await spawn_local(tracked_producer());
+  co_await spawn_local(tracked_consumer());
 
   // Wait for operations to complete
   co_await sleep(200ms);
@@ -198,8 +196,7 @@ async<void> test_channel_close() {
     receiver_completed = true;
   };
 
-  auto& exec = *co_await current_executor();
-  co_spawn(exec, receiver());
+  co_await spawn_local(receiver());
 
   // Allow receiver to start waiting
   co_await sleep(10ms);
@@ -275,9 +272,8 @@ async<void> test_ping_pong() {
     co_return;
   };
 
-  auto& exec = *co_await current_executor();
-  co_spawn(exec, server());
-  co_spawn(exec, client());
+  co_await spawn_local(server());
+  co_await spawn_local(client());
 
   co_await sleep(100ms);
 
@@ -327,11 +323,10 @@ async<void> test_multiple_producers_consumers() {
   };
 
   // Start 2 producers and 2 consumers
-  auto& exec = *co_await current_executor();
-  co_spawn(exec, producer(1, &producer1_completed));
-  co_spawn(exec, producer(2, &producer2_completed));
-  co_spawn(exec, consumer(1, &consumer1_completed));
-  co_spawn(exec, consumer(2, &consumer2_completed));
+  co_await spawn_local(producer(1, &producer1_completed));
+  co_await spawn_local(producer(2, &producer2_completed));
+  co_await spawn_local(consumer(1, &consumer1_completed));
+  co_await spawn_local(consumer(2, &consumer2_completed));
 
 #ifdef CORO_TEST_RUNNER_VERY_SLOW
   co_await sleep(300ms);

test/coro_condition_variable.cpp

@@ -157,9 +157,8 @@ async<void> cv_producer_consumer_test() {
     co_return consumed;
   };
 
-  auto exec = co_await current_executor();
-  co_spawn(*exec, producer(1));
-  co_spawn(*exec, producer(2));
+  co_await spawn_local(producer(1));
+  co_await spawn_local(producer(2));
 
   auto c1 = consumer(1);
   auto c2 = consumer(2);