diff --git a/cmake/develop.cmake b/cmake/develop.cmake
index 864fb2b5..e9ec2529 100644
--- a/cmake/develop.cmake
+++ b/cmake/develop.cmake
@@ -39,7 +39,11 @@ int main()
 endmacro()
 
 # Enable address sanitizer
-option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" ON)
+if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" OFF)
+else()
+    option(ENABLE_SANITIZER "Enable sanitizer(Debug+Gcc/Clang/AppleClang)" ON)
+endif()
 if(ENABLE_SANITIZER AND NOT MSVC)
     if(CMAKE_BUILD_TYPE STREQUAL "Debug")
         check_asan(HAS_ASAN)
diff --git a/include/async_simple/CMakeLists.txt b/include/async_simple/CMakeLists.txt
deleted file mode 100644
index 59b77423..00000000
--- a/include/async_simple/CMakeLists.txt
+++ /dev/null
@@ -1,73 +0,0 @@
-file(GLOB coro_src "coro/*.cpp")
-file(GLOB executors_src "executors/*.cpp")
-
-if(${UTHREAD})
-  file(GLOB uthread_src "uthread/internal/*.cc")
-  if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND
-      CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "13")
-  endif()
-file(GLOB uthread_asm_src "uthread/internal/${CMAKE_SYSTEM_NAME}/${CMAKE_SYSTEM_PROCESSOR}/*.S")
-endif()
-
-file(GLOB headers "*.h")
-file(GLOB coro_header "coro/*.h")
-file(GLOB executors_header "executors/*.h")
-file(GLOB experimental_header "experimental/*.h")
-file(GLOB util_header "util/*.h")
-if(UTHREAD)
-  file(GLOB uthread_header "uthread/*.h")
-  file(GLOB uthread_internal_header "uthread/internal/*.h")
-endif()
-
-
-set(SRCS
-  ${coro_src}
-  ${executors_src}
-  )
-if(UTHREAD)
-  list(APPEND SRCS ${uthread_src})
-  list(APPEND SRCS ${uthread_asm_src})
-endif()
-
-if(NOT CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
-  add_library(async_simple_static STATIC ${SRCS})
-  add_library(async_simple SHARED ${SRCS})
-  target_link_libraries(async_simple PUBLIC libasync_simple)
-  target_link_libraries(async_simple_static PUBLIC libasync_simple)
-
-  set_target_properties(async_simple_static PROPERTIES OUTPUT_NAME "async_simple")
-
-  install(TARGETS async_simple DESTINATION lib/)
-  install(TARGETS async_simple_static DESTINATION lib/)
-else()
-  add_library(async_simple STATIC ${SRCS})
-  target_link_libraries(async_simple PUBLIC libasync_simple)
-  install(TARGETS async_simple DESTINATION lib/)
-endif()
-
-set_target_properties(async_simple PROPERTIES 
-                                   VERSION ${PROJECT_VERSION}
-                                   SOVERSION ${PROJECT_VERSION_MAJOR})
-
-install(FILES ${headers} DESTINATION include/async_simple)
-install(FILES ${coro_header} DESTINATION include/async_simple/coro)
-install(FILES ${executors_header} DESTINATION include/async_simple/executors)
-install(FILES ${experimental_header} DESTINATION include/async_simple/experimental)
-install(FILES ${util_header} DESTINATION include/async_simple/util)
-if(UTHREAD)
-  install(FILES ${uthread_header} DESTINATION include/async_simple/uthread)
-  install(FILES ${uthread_internal_header} DESTINATION include/async_simple/uthread/internal)
-endif()
-
-if (${ASYNC_SIMPLE_ENABLE_TESTS})
-  add_subdirectory(test)
-  add_subdirectory(util/test)
-  add_subdirectory(coro/test)
-  add_subdirectory(executors/test)
-  if(UTHREAD)
-    add_subdirectory(uthread/test)
-  endif()
-endif()
-if (NOT TARGET async_simple::async_simple_header_only)
-  add_library(async_simple::async_simple_header_only ALIAS libasync_simple)
-endif ()
diff --git a/include/async_simple/Common.h b/include/async_simple/Common.h
index a82a40c3..bde017e6 100644
--- a/include/async_simple/Common.h
+++ b/include/async_simple/Common.h
@@ -44,6 +44,20 @@
 #endif  // __SANITIZE_ADDRESS__
 #endif  // __GNUC__
 
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::coro_only_destroy_when_complete)
+#define CORO_ONLY_DESTROY_WHEN_DONE [[ACC::coro_only_destroy_when_complete]]
+#else
+#define CORO_ONLY_DESTROY_WHEN_DONE
+#endif
+
+#if defined(__alibaba_clang__) && \
+    __has_cpp_attribute(ACC::elideable_after_await)
+#define ELIDEABLE_AFTER_AWAIT [[ACC::elideable_after_await]]
+#else
+#define ELIDEABLE_AFTER_AWAIT
+#endif
+
 namespace async_simple {
 // Different from assert, logicAssert is meaningful in
 // release mode. logicAssert should be used in case that
diff --git a/include/async_simple/Executor.h b/include/async_simple/Executor.h
index 47eb8b72..d1edfedf 100644
--- a/include/async_simple/Executor.h
+++ b/include/async_simple/Executor.h
@@ -20,7 +20,9 @@
 #include <functional>
 #include <string>
 #include <thread>
+#include "async_simple/MoveWrapper.h"
 #include "async_simple/experimental/coroutine.h"
+#include "async_simple/util/move_only_function.h"
 
 namespace async_simple {
 // Stat information for an executor.
@@ -86,6 +88,13 @@ class Executor {
     // func will not be executed. In case schedule return true, the executor
     // should guarantee that the func would be executed.
     virtual bool schedule(Func func) = 0;
+
+    // Schedule a move only functor
+    bool schedule_move_only(util::move_only_function<void()> func) {
+        MoveWrapper<decltype(func)> tmp(std::move(func));
+        return schedule([func = tmp]() { func.get()(); });
+    }
+
     // Return true if caller runs in the executor.
     virtual bool currentThreadInExecutor() const {
         throw std::logic_error("Not implemented");
@@ -143,10 +152,7 @@ class Executor::TimeAwaiter {
 
     template <typename PromiseType>
     void await_suspend(std::coroutine_handle<PromiseType> continuation) {
-        std::function<void()> func = [c = continuation]() mutable {
-            c.resume();
-        };
-        _ex->schedule(func, _dur);
+        _ex->schedule(std::move(continuation), _dur);
     }
     void await_resume() const noexcept {}
 
diff --git a/include/async_simple/Future.h b/include/async_simple/Future.h
index fc6ce832..014e9578 100644
--- a/include/async_simple/Future.h
+++ b/include/async_simple/Future.h
@@ -58,6 +58,7 @@ class Future {
 
 public:
     using value_type = T;
+
     Future(FutureState<inner_value_type>* fs) : _sharedState(fs) {
         if (_sharedState) {
             _sharedState->attachOne();
@@ -89,6 +90,8 @@ class Future {
         return *this;
     }
 
+    auto coAwait(Executor*) && noexcept { return std::move(*this); }
+
 public:
     bool valid() const {
         return _sharedState != nullptr || _localState.hasResult();
@@ -349,7 +352,9 @@ template <typename T>
 Future<T> makeReadyFuture(std::exception_ptr ex) {
     return Future<T>(Try<T>(ex));
 }
-inline Future<void> makeReadyFuture() { return Future<void>(Try<Unit>()); }
+inline Future<void> makeReadyFuture() {
+    return Future<void>(Try<Unit>(Unit()));
+}
 
 }  // namespace async_simple
 
diff --git a/include/async_simple/FutureState.h b/include/async_simple/FutureState.h
index 9cac785f..7f495839 100644
--- a/include/async_simple/FutureState.h
+++ b/include/async_simple/FutureState.h
@@ -27,8 +27,8 @@
 #include <thread>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
+#include "async_simple/util/move_only_function.h"
 
 namespace async_simple {
 
@@ -62,7 +62,7 @@ constexpr State operator&(State lhs, State rhs) {
 template <typename T>
 class FutureState {
 private:
-    using Continuation = std::function<void(Try<T>&& value)>;
+    using Continuation = util::move_only_function<void(Try<T>&& value)>;
 
 private:
     // A helper to help FutureState to count the references to guarantee
@@ -228,11 +228,10 @@ class FutureState {
     void setContinuation(F&& func) {
         logicAssert(!hasContinuation(),
                     "FutureState already has a continuation");
-        MoveWrapper<F> lambdaFunc(std::move(func));
-        new (&_continuation) Continuation([lambdaFunc](Try<T>&& v) mutable {
-            auto& lambda = lambdaFunc.get();
-            lambda(std::forward<Try<T>>(v));
-        });
+        new (&_continuation)
+            Continuation([func = std::move(func)](Try<T>&& v) mutable {
+                func(std::forward<Try<T>>(v));
+            });
 
         auto state = _state.load(std::memory_order_acquire);
         switch (state) {
diff --git a/include/async_simple/LocalState.h b/include/async_simple/LocalState.h
index f205a045..297de380 100644
--- a/include/async_simple/LocalState.h
+++ b/include/async_simple/LocalState.h
@@ -27,7 +27,6 @@
 #include <utility>
 #include "async_simple/Common.h"
 #include "async_simple/Executor.h"
-#include "async_simple/MoveWrapper.h"
 #include "async_simple/Try.h"
 
 namespace async_simple {
diff --git a/include/async_simple/MoveWrapper.h b/include/async_simple/MoveWrapper.h
index 698039a3..0fbfb9b4 100644
--- a/include/async_simple/MoveWrapper.h
+++ b/include/async_simple/MoveWrapper.h
@@ -18,6 +18,7 @@
 #define ASYNC_SIMPLE_MOVEWRAPPER_H
 
 #include <exception>
+
 #include "async_simple/Common.h"
 
 namespace async_simple {
@@ -26,23 +27,23 @@ namespace async_simple {
 // copy as move.
 template <typename T>
 class MoveWrapper {
-public:
-    MoveWrapper() = default;
-    MoveWrapper(T&& value) : _value(std::move(value)) {}
+ public:
+  MoveWrapper() = default;
+  MoveWrapper(T&& value) : _value(std::move(value)) {}
 
-    MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
-    MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
+  MoveWrapper(const MoveWrapper& other) : _value(std::move(other._value)) {}
+  MoveWrapper(MoveWrapper&& other) : _value(std::move(other._value)) {}
 
-    MoveWrapper& operator=(const MoveWrapper&) = delete;
-    MoveWrapper& operator=(MoveWrapper&&) = delete;
+  MoveWrapper& operator=(const MoveWrapper&) = delete;
+  MoveWrapper& operator=(MoveWrapper&&) = delete;
 
-    T& get() { return _value; }
-    const T& get() const { return _value; }
+  T& get() { return _value; }
+  const T& get() const { return _value; }
 
-    ~MoveWrapper() {}
+  ~MoveWrapper() {}
 
-private:
-    mutable T _value;
+ private:
+  mutable T _value;
 };
 
 }  // namespace async_simple
diff --git a/include/async_simple/Try.h b/include/async_simple/Try.h
index 6fa2be33..8ec40189 100644
--- a/include/async_simple/Try.h
+++ b/include/async_simple/Try.h
@@ -118,7 +118,7 @@ class Try {
     }
     std::exception_ptr getException() const {
         logicAssert(std::holds_alternative<std::exception_ptr>(_value),
-                    "Try object do not has on error");
+                    "Try object do not has an error");
         return std::get<std::exception_ptr>(_value);
     }
 
diff --git a/include/async_simple/coro/Collect.h b/include/async_simple/coro/Collect.h
index 93e48e53..218cd7b4 100644
--- a/include/async_simple/coro/Collect.h
+++ b/include/async_simple/coro/Collect.h
@@ -26,6 +26,7 @@
 #include <vector>
 #include "async_simple/Common.h"
 #include "async_simple/Try.h"
+#include "async_simple/Unit.h"
 #include "async_simple/coro/CountEvent.h"
 #include "async_simple/coro/Lazy.h"
 #include "async_simple/experimental/coroutine.h"
@@ -66,9 +67,7 @@ struct CollectAnyResult {
     bool hasError() const { return _value.hasError(); }
     // Require hasError() == true. Otherwise it is UB to call
     // this method.
-    std::exception_ptr getException() const {
-        return _value.getException();
-    }
+    std::exception_ptr getException() const { return _value.getException(); }
 
     // Require hasError() == false. Otherwise it is UB to call
     // value() method.
@@ -85,7 +84,7 @@ struct CollectAnyResult {
 #endif
 };
 
-template <typename LazyType, typename InAlloc>
+template <typename LazyType, typename InAlloc, typename Callback = Unit>
 struct CollectAnyAwaiter {
     using ValueType = typename LazyType::ValueType;
     using ResultType = CollectAnyResult<ValueType>;
@@ -93,10 +92,17 @@ struct CollectAnyAwaiter {
     CollectAnyAwaiter(std::vector<LazyType, InAlloc>&& input)
         : _input(std::move(input)), _result(nullptr) {}
 
+    CollectAnyAwaiter(std::vector<LazyType, InAlloc>&& input, Callback callback)
+        : _input(std::move(input)),
+          _result(nullptr),
+          _callback(std::move(callback)) {}
+
     CollectAnyAwaiter(const CollectAnyAwaiter&) = delete;
     CollectAnyAwaiter& operator=(const CollectAnyAwaiter&) = delete;
     CollectAnyAwaiter(CollectAnyAwaiter&& other)
-        : _input(std::move(other._input)), _result(std::move(other._result)) {}
+        : _input(std::move(other._input)),
+          _result(std::move(other._result)),
+          _callback(std::move(other._callback)) {}
 
     bool await_ready() const noexcept {
         return _input.empty() ||
@@ -115,6 +121,7 @@ struct CollectAnyAwaiter {
         // if any coroutine finishes before this function.
         auto result = std::make_shared<ResultType>();
         auto event = std::make_shared<detail::CountEvent>(input.size());
+        auto callback = std::move(_callback);
 
         _result = result;
         for (size_t i = 0;
@@ -124,26 +131,130 @@ struct CollectAnyAwaiter {
                 input[i]._coro.promise()._executor = executor;
             }
 
-            input[i].start([i = i, size = input.size(), r = result,
-                            c = continuation,
-                            e = event](Try<ValueType>&& result) mutable {
-                assert(e != nullptr);
-                auto count = e->downCount();
-                if (count == size + 1) {
-                    r->_idx = i;
-                    r->_value = std::move(result);
-                    c.resume();
-                }
-            });
+            if constexpr (std::is_same_v<Callback, Unit>) {
+                (void)callback;
+                input[i].start([i, size = input.size(), r = result,
+                                c = continuation,
+                                e = event](Try<ValueType>&& result) mutable {
+                    assert(e != nullptr);
+                    auto count = e->downCount();
+                    if (count == size + 1) {
+                        r->_idx = i;
+                        r->_value = std::move(result);
+                        c.resume();
+                    }
+                });
+            } else {
+                input[i].start([i, size = input.size(), r = result,
+                                c = continuation, e = event,
+                                callback](Try<ValueType>&& result) mutable {
+                    assert(e != nullptr);
+                    auto count = e->downCount();
+                    if (count == size + 1) {
+                        r->_idx = i;
+                        (*callback)(i, std::move(result));
+                        c.resume();
+                    }
+                });
+            }
         }  // end for
     }
     auto await_resume() {
-        assert(_result != nullptr);
-        return std::move(*_result);
+        if constexpr (std::is_same_v<Callback, Unit>) {
+            assert(_result != nullptr);
+            return std::move(*_result);
+        } else {
+            return _result->index();
+        }
     }
 
     std::vector<LazyType, InAlloc> _input;
     std::shared_ptr<ResultType> _result;
+    [[no_unique_address]] Callback _callback;
+};
+
+template <typename... Ts>
+struct CollectAnyVariadicPairAwaiter {
+    using InputType = std::tuple<Ts...>;
+
+    CollectAnyVariadicPairAwaiter(Ts&&... inputs)
+        : _input(std::move(inputs)...), _result(nullptr) {}
+
+    CollectAnyVariadicPairAwaiter(InputType&& inputs)
+        : _input(std::move(inputs)), _result(nullptr) {}
+
+    CollectAnyVariadicPairAwaiter(const CollectAnyVariadicPairAwaiter&) =
+        delete;
+    CollectAnyVariadicPairAwaiter& operator=(
+        const CollectAnyVariadicPairAwaiter&) = delete;
+    CollectAnyVariadicPairAwaiter(CollectAnyVariadicPairAwaiter&& other)
+        : _input(std::move(other._input)), _result(std::move(other._result)) {}
+
+    bool await_ready() const noexcept {
+        return _result && _result->has_value();
+    }
+
+    void await_suspend(std::coroutine_handle<> continuation) {
+        auto promise_type =
+            std::coroutine_handle<LazyPromiseBase>::from_address(
+                continuation.address())
+                .promise();
+        auto executor = promise_type._executor;
+        auto event =
+            std::make_shared<detail::CountEvent>(std::tuple_size<InputType>());
+        auto result = std::make_shared<std::optional<size_t>>();
+        _result = result;
+
+        auto input = std::move(_input);
+
+        [&]<size_t... I>(std::index_sequence<I...>) {
+            (
+                [&](auto& lazy, auto& callback) {
+                    if (result->has_value()) {
+                        return;
+                    }
+
+                    if (!lazy._coro.promise()._executor) {
+                        lazy._coro.promise()._executor = executor;
+                    }
+
+                    lazy.start([result, event, continuation,
+                                callback](auto&& res) mutable {
+                        auto count = event->downCount();
+                        if (count == std::tuple_size<InputType>() + 1) {
+                            callback(std::move(res));
+                            *result = I;
+                            continuation.resume();
+                        }
+                    });
+                }(std::get<0>(std::get<I>(input)),
+                  std::get<1>(std::get<I>(input))),
+                ...);
+        }
+        (std::make_index_sequence<sizeof...(Ts)>());
+    }
+
+    auto await_resume() {
+        assert(_result != nullptr);
+        return std::move(_result->value());
+    }
+
+    std::tuple<Ts...> _input;
+    std::shared_ptr<std::optional<size_t>> _result;
+};
+
+template <typename... Ts>
+struct SimpleCollectAnyVariadicPairAwaiter {
+    using InputType = std::tuple<Ts...>;
+
+    InputType _inputs;
+
+    SimpleCollectAnyVariadicPairAwaiter(Ts&&... inputs)
+        : _inputs(std::move(inputs)...) {}
+
+    auto coAwait(Executor* ex) {
+        return CollectAnyVariadicPairAwaiter(std::move(_inputs));
+    }
 };
 
 template <template <typename> typename LazyType, typename... Ts>
@@ -226,19 +337,29 @@ struct CollectAnyVariadicAwaiter {
     std::shared_ptr<std::optional<ResultType>> _result;
 };
 
-template <typename T, typename InAlloc>
+template <typename T, typename InAlloc, typename Callback = Unit>
 struct SimpleCollectAnyAwaitable {
     using ValueType = T;
     using LazyType = Lazy<T>;
     using VectorType = std::vector<LazyType, InAlloc>;
 
     VectorType _input;
+    [[no_unique_address]] Callback _callback;
 
     SimpleCollectAnyAwaitable(std::vector<LazyType, InAlloc>&& input)
         : _input(std::move(input)) {}
 
+    SimpleCollectAnyAwaitable(std::vector<LazyType, InAlloc>&& input,
+                              Callback callback)
+        : _input(std::move(input)), _callback(std::move(callback)) {}
+
     auto coAwait(Executor* ex) {
-        return CollectAnyAwaiter<LazyType, InAlloc>(std::move(_input));
+        if constexpr (std::is_same_v<Callback, Unit>) {
+            return CollectAnyAwaiter<LazyType, InAlloc>(std::move(_input));
+        } else {
+            return CollectAnyAwaiter<LazyType, InAlloc, Callback>(
+                std::move(_input), std::move(_callback));
+        }
     }
 };
 
@@ -371,7 +492,9 @@ inline auto collectAllWindowedImpl(size_t maxConcurrency,
     }
     size_t start = 0;
     while (start < input_size) {
-        size_t end = std::min(input_size, start + maxConcurrency);
+        size_t end = (std::min)(
+            input_size,
+            start + maxConcurrency);  // Avoid to conflict with Windows macros.
         std::vector<LazyType> tmp_group(
             std::make_move_iterator(input.begin() + start),
             std::make_move_iterator(input.begin() + end));
@@ -486,15 +609,16 @@ inline auto collectAllVariadicImpl(LazyType<Ts>&&... awaitables) {
 }
 
 // collectAny
-
 template <typename T, template <typename> typename LazyType,
-          typename IAlloc = std::allocator<LazyType<T>>>
-inline auto collectAnyImpl(std::vector<LazyType<T>, IAlloc> input) {
-    using AT =
-        std::conditional_t<std::is_same_v<LazyType<T>, Lazy<T>>,
-                           detail::SimpleCollectAnyAwaitable<T, IAlloc>,
-                           detail::CollectAnyAwaiter<LazyType<T>, IAlloc>>;
-    return AT(std::move(input));
+          typename IAlloc = std::allocator<LazyType<T>>,
+          typename Callback = Unit>
+inline auto collectAnyImpl(std::vector<LazyType<T>, IAlloc> input,
+                           Callback callback = {}) {
+    using AT = std::conditional_t<
+        std::is_same_v<LazyType<T>, Lazy<T>>,
+        detail::SimpleCollectAnyAwaitable<T, IAlloc, Callback>,
+        detail::CollectAnyAwaiter<LazyType<T>, IAlloc, Callback>>;
+    return AT(std::move(input), std::move(callback));
 }
 
 // collectAnyVariadic
@@ -507,6 +631,15 @@ inline auto CollectAnyVariadicImpl(LazyType<Ts>&&... inputs) {
     return AT(std::move(inputs)...);
 }
 
+// collectAnyVariadicPair
+template <typename T, typename... Ts>
+inline auto CollectAnyVariadicPairImpl(T&& input, Ts&&... inputs) {
+    using U = std::tuple_element_t<0, std::remove_cvref_t<T>>;
+    using AT = std::conditional_t<is_lazy<U>::value,
+                                  SimpleCollectAnyVariadicPairAwaiter<T, Ts...>,
+                                  CollectAnyVariadicPairAwaiter<T, Ts...>>;
+    return AT(std::move(input), std::move(inputs)...);
+}
 }  // namespace detail
 
 template <typename T, template <typename> typename LazyType,
@@ -515,12 +648,27 @@ inline auto collectAny(std::vector<LazyType<T>, IAlloc>&& input) {
     return detail::collectAnyImpl(std::move(input));
 }
 
+template <typename T, template <typename> typename LazyType,
+          typename IAlloc = std::allocator<LazyType<T>>, typename Callback>
+inline auto collectAny(std::vector<LazyType<T>, IAlloc>&& input,
+                       Callback callback) {
+    auto cb = std::make_shared<Callback>(std::move(callback));
+    return detail::collectAnyImpl(std::move(input), std::move(cb));
+}
+
 template <template <typename> typename LazyType, typename... Ts>
 inline auto collectAny(LazyType<Ts>... awaitables) {
     static_assert(sizeof...(Ts), "collectAny need at least one param!");
     return detail::CollectAnyVariadicImpl(std::move(awaitables)...);
 }
 
+// collectAny with std::pair<Lazy, CallbackFunction>
+template <typename... Ts>
+inline auto collectAny(Ts&&... inputs) {
+    static_assert(sizeof...(Ts), "collectAny need at least one param!");
+    return detail::CollectAnyVariadicPairImpl(std::move(inputs)...);
+}
+
 // The collectAll() function can be used to co_await on a vector of LazyType
 // tasks in **one thread**,and producing a vector of Try values containing each
 // of the results.
diff --git a/include/async_simple/coro/CountEvent.h b/include/async_simple/coro/CountEvent.h
index eabfeafc..62e22dc3 100644
--- a/include/async_simple/coro/CountEvent.h
+++ b/include/async_simple/coro/CountEvent.h
@@ -25,8 +25,6 @@ namespace async_simple {
 
 namespace coro {
 
-class CountEvent;
-
 namespace detail {
 
 // CountEvent is a count-down event.
diff --git a/include/async_simple/coro/DetachedCoroutine.h b/include/async_simple/coro/DetachedCoroutine.h
index 301f4cd2..ca11e5a6 100644
--- a/include/async_simple/coro/DetachedCoroutine.h
+++ b/include/async_simple/coro/DetachedCoroutine.h
@@ -57,6 +57,7 @@ struct DetachedCoroutine {
         // Hint to gdb script for that there is no continuation for
         // DetachedCoroutine.
         std::coroutine_handle<> _continuation = nullptr;
+        void* _lazy_local = nullptr;
     };
 };
 
diff --git a/include/async_simple/coro/Dispatch.h b/include/async_simple/coro/Dispatch.h
new file mode 100644
index 00000000..e79009e9
--- /dev/null
+++ b/include/async_simple/coro/Dispatch.h
@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2022, Alibaba Group Holding Limited;
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ASYNC_SIMPLE_CORO_DISPATCH_H
+#define ASYNC_SIMPLE_CORO_DISPATCH_H
+
+#include "async_simple/Common.h"
+#include "async_simple/Executor.h"
+#include "async_simple/coro/Lazy.h"
+#include "async_simple/experimental/coroutine.h"
+
+#include <cassert>
+#include <type_traits>
+
+namespace async_simple {
+namespace coro {
+
+namespace detail {
+
+// based on c++ coroutine common abi.
+// it is not supported that the PromiseType's align is larger than the size of
+// two function pointer.
+inline std::coroutine_handle<> GetContinuationFromHandle(
+    std::coroutine_handle<> h) {
+    constexpr size_t promise_offset = 2 * sizeof(void*);
+    char* ptr = static_cast<char*>(h.address());
+    ptr = ptr + promise_offset;
+    return std::coroutine_handle<>::from_address(
+        *static_cast<void**>(static_cast<void*>(ptr)));
+}
+
+inline void ChangeLaziessExecutorTo(std::coroutine_handle<> h, Executor* ex) {
+    while (true) {
+        std::coroutine_handle<> continuation = GetContinuationFromHandle(h);
+        if (!continuation.address()) {
+            break;
+        }
+        auto& promise =
+            std::coroutine_handle<LazyPromiseBase>::from_address(h.address())
+                .promise();
+        promise._executor = ex;
+        h = continuation;
+    }
+}
+
+class DispatchAwaiter {
+public:
+    explicit DispatchAwaiter(Executor* ex) noexcept : _ex(ex) {
+        assert(_ex != nullptr);
+    }
+
+    bool await_ready() const noexcept { return false; }
+
+    template <typename PromiseType>
+    bool await_suspend(std::coroutine_handle<PromiseType> h) {
+        static_assert(std::is_base_of<LazyPromiseBase, PromiseType>::value,
+                      "dispatch is only allowed to be called by Lazy");
+        if (h.promise()._executor == _ex) {
+            return false;
+        }
+        Executor* old_ex = h.promise()._executor;
+        ChangeLaziessExecutorTo(h, _ex);
+        bool succ = _ex->schedule(std::move(h));
+        // cannot access *this after schedule.
+        // If the scheduling fails, we must change the executor back to its
+        // original value, as the user may catch exceptions and handle them
+        // themselves, which can result in inconsistencies between the executor
+        // recorded by Lazy and the actual executor running.
+        if (succ == false)
+            AS_UNLIKELY {
+                ChangeLaziessExecutorTo(h, old_ex);
+                throw std::runtime_error("dispatch to executor failed");
+            }
+        return true;
+    }
+
+    void await_resume() noexcept {}
+
+private:
+    Executor* _ex;
+};
+
+class DispatchAwaitable {
+public:
+    explicit DispatchAwaitable(Executor* ex) : _ex(ex) {}
+
+    auto coAwait(Executor*) { return DispatchAwaiter(_ex); }
+
+private:
+    Executor* _ex;
+};
+
+}  // namespace detail
+
+// schedule this Lazy to ex for execution
+inline detail::DispatchAwaitable dispatch(Executor* ex) {
+    logicAssert(ex != nullptr, "dispatch's param should not be nullptr");
+    return detail::DispatchAwaitable(ex);
+}
+
+}  // namespace coro
+}  // namespace async_simple
+
+#endif
diff --git a/include/async_simple/coro/FutureAwaiter.h b/include/async_simple/coro/FutureAwaiter.h
index 9de2293c..b54c9044 100644
--- a/include/async_simple/coro/FutureAwaiter.h
+++ b/include/async_simple/coro/FutureAwaiter.h
@@ -17,24 +17,44 @@
 #define ASYNC_SIMPLE_CORO_FUTURE_AWAITER_H
 
 #include "async_simple/Future.h"
+#include "async_simple/coro/Lazy.h"
 #include "async_simple/experimental/coroutine.h"
 
+#include <type_traits>
+
 namespace async_simple {
 
+namespace coro::detail {
 template <typename T>
-auto operator co_await(Future<T>&& future) {
-    struct FutureAwaiter {
-        Future<T> future_;
+struct FutureAwaiter {
+    Future<T> future_;
+
+    bool await_ready() { return future_.hasResult(); }
 
-        bool await_ready() { return future_.hasResult(); }
-        void await_suspend(coro::CoroHandle<> continuation) {
-            future_.setContinuation(
-                [continuation](Try<T>&& t) mutable { continuation.resume(); });
+    template <typename PromiseType>
+    void await_suspend(std::coroutine_handle<PromiseType> continuation) {
+        static_assert(std::is_base_of_v<LazyPromiseBase, PromiseType>,
+                      "FutureAwaiter is only allowed to be called by Lazy");
+        Executor* ex = continuation.promise()._executor;
+        Executor::Context ctx = Executor::NULLCTX;
+        if (ex != nullptr) {
+            ctx = ex->checkout();
         }
-        auto await_resume() { return std::move(future_.value()); }
-    };
+        future_.setContinuation([continuation, ex, ctx](Try<T>&& t) mutable {
+            if (ex != nullptr) {
+                ex->checkin(continuation, ctx);
+            } else {
+                continuation.resume();
+            }
+        });
+    }
+    auto await_resume() { return std::move(future_.value()); }
+};
+}  // namespace coro::detail
 
-    return FutureAwaiter{std::move(future)};
+template <typename T>
+auto operator co_await(Future<T>&& future) {
+    return coro::detail::FutureAwaiter<T>{std::move(future)};
 }
 
 template <typename T>
diff --git a/include/async_simple/coro/Generator.h b/include/async_simple/coro/Generator.h
index 0c6eb008..21096efc 100644
--- a/include/async_simple/coro/Generator.h
+++ b/include/async_simple/coro/Generator.h
@@ -17,6 +17,11 @@
 #ifndef ASYNC_SIMPLE_CORO_GENERATOR_H
 #define ASYNC_SIMPLE_CORO_GENERATOR_H
 
+#if defined(__clang__) && __clang_major__ == 15
+// See: https://github.com/alibaba/async_simple/issues/372
+#warning "Clang 15 is not supported for Generator due to some issues."
+#endif
+
 #if __has_include(<generator>)
 
 #include <generator>
diff --git a/include/async_simple/coro/Lazy.h b/include/async_simple/coro/Lazy.h
index 0b05b134..1ece44c8 100644
--- a/include/async_simple/coro/Lazy.h
+++ b/include/async_simple/coro/Lazy.h
@@ -18,6 +18,7 @@
 
 #include <atomic>
 #include <concepts>
+#include <cstddef>
 #include <cstdio>
 #include <exception>
 #include <variant>
@@ -41,12 +42,15 @@ class Lazy;
 // execute, we could write:
 //
 // ```C++
-//  co_await Yield();
+//  co_await Yield{};
 // ```
 //
 // This would suspend the executing coroutine.
 struct Yield {};
 
+template <typename T = void>
+struct LazyLocals {};
+
 namespace detail {
 template <class, typename OAlloc, bool Para>
 struct CollectAllAwaiter;
@@ -54,12 +58,15 @@ struct CollectAllAwaiter;
 template <bool Para, template <typename> typename LazyType, typename... Ts>
 struct CollectAllVariadicAwaiter;
 
-template <typename LazyType, typename IAlloc>
+template <typename LazyType, typename IAlloc, typename Callback>
 struct CollectAnyAwaiter;
 
 template <template <typename> typename LazyType, typename... Ts>
 struct CollectAnyVariadicAwaiter;
 
+template <typename... Ts>
+struct CollectAnyVariadicPairAwaiter;
+
 }  // namespace detail
 
 namespace detail {
@@ -74,6 +81,10 @@ class LazyPromiseBase {
         bool await_ready() const noexcept { return false; }
         template <typename PromiseType>
         auto await_suspend(std::coroutine_handle<PromiseType> h) noexcept {
+            static_assert(
+                std::is_base_of<LazyPromiseBase, PromiseType>::value,
+                "the final awaiter is only allowed to be called by Lazy");
+
             return h.promise()._continuation;
         }
         void await_resume() noexcept {}
@@ -82,13 +93,15 @@ class LazyPromiseBase {
     struct YieldAwaiter {
         YieldAwaiter(Executor* executor) : _executor(executor) {}
         bool await_ready() const noexcept { return false; }
-        void await_suspend(std::coroutine_handle<> handle) {
+        template <typename PromiseType>
+        void await_suspend(std::coroutine_handle<PromiseType> handle) {
+            static_assert(
+                std::is_base_of<LazyPromiseBase, PromiseType>::value,
+                "'co_await Yield' is only allowed to be called by Lazy");
+
             logicAssert(_executor,
                         "Yielding is only meaningful with an executor!");
-            std::function<void()> func = [h = std::move(handle)]() mutable {
-                h.resume();
-            };
-            _executor->schedule(func);
+            _executor->schedule(std::move(handle));
         }
         void await_resume() noexcept {}
 
@@ -97,7 +110,7 @@ class LazyPromiseBase {
     };
 
 public:
-    LazyPromiseBase() : _executor(nullptr) {}
+    LazyPromiseBase() noexcept : _executor(nullptr), _lazy_local(nullptr) {}
     // Lazily started, coroutine will not execute until first resume() is called
     std::suspend_always initial_suspend() noexcept { return {}; }
     FinalAwaiter final_suspend() noexcept { return {}; }
@@ -111,26 +124,38 @@ class LazyPromiseBase {
     auto await_transform(CurrentExecutor) {
         return ReadyAwaiter<Executor*>(_executor);
     }
+
+    template <typename T>
+    auto await_transform(LazyLocals<T>) {
+        return ReadyAwaiter<T*>(static_cast<T*>(_lazy_local));
+    }
+
     auto await_transform(Yield) { return YieldAwaiter(_executor); }
 
     /// IMPORTANT: _continuation should be the first member due to the
     /// requirement of dbg script.
     std::coroutine_handle<> _continuation;
     Executor* _executor;
+    void* _lazy_local;
 };
 
 template <typename T>
 class LazyPromise : public LazyPromiseBase {
 public:
+    static_assert(alignof(T) <= alignof(::max_align_t),
+                  "async_simple doesn't allow Lazy with over aligned object");
+
     LazyPromise() noexcept {}
     ~LazyPromise() noexcept {}
 
     Lazy<T> get_return_object() noexcept;
 
+    static Lazy<T> get_return_object_on_allocation_failure() noexcept;
+
     template <typename V>
     void return_value(V&& value) noexcept(
-        std::is_nothrow_constructible_v<
-            T, V&&>) requires std::is_convertible_v<V&&, T> {
+        std::is_nothrow_constructible_v<T, V&&>) requires
+        std::is_convertible_v<V&&, T> {
         _value.template emplace<T>(std::forward<V>(value));
     }
     void unhandled_exception() noexcept {
@@ -170,7 +195,12 @@ class LazyPromise : public LazyPromiseBase {
 template <>
 class LazyPromise<void> : public LazyPromiseBase {
 public:
+    LazyPromise() noexcept {}
+    ~LazyPromise() noexcept {}
+
     Lazy<void> get_return_object() noexcept;
+    static Lazy<void> get_return_object_on_allocation_failure() noexcept;
+
     void return_void() noexcept {}
     void unhandled_exception() noexcept {
         _exception = std::current_exception();
@@ -254,11 +284,23 @@ class LazyBase {
         using Base = detail::LazyAwaiterBase<T>;
         AwaiterBase(Handle coro) : Base(coro) {}
 
-        AS_INLINE auto await_suspend(
-            std::coroutine_handle<> continuation) noexcept(!reschedule) {
+        template <typename PromiseType>
+        AS_INLINE auto await_suspend(std::coroutine_handle<PromiseType>
+                                         continuation) noexcept(!reschedule) {
+            static_assert(
+                std::is_base_of<LazyPromiseBase, PromiseType>::value ||
+                    std::is_same_v<detail::DetachedCoroutine::promise_type,
+                                   PromiseType>,
+                "'co_await Lazy' is only allowed to be called by Lazy or "
+                "DetachedCoroutine");
+
             // current coro started, caller becomes my continuation
             this->_handle.promise()._continuation = continuation;
-
+            if constexpr (std::is_base_of<LazyPromiseBase,
+                                          PromiseType>::value) {
+                this->_handle.promise()._lazy_local =
+                    continuation.promise()._lazy_local;
+            }
             return awaitSuspendImpl();
         }
 
@@ -268,8 +310,7 @@ class LazyBase {
                 // executor schedule performed
                 auto& pr = this->_handle.promise();
                 logicAssert(pr._executor, "RescheduleLazy need executor");
-                pr._executor->schedule(
-                    [h = this->_handle]() mutable { h.resume(); });
+                pr._executor->schedule(this->_handle);
             } else {
                 return this->_handle;
             }
@@ -305,8 +346,8 @@ class LazyBase {
             _coro = nullptr;
         }
     };
-    explicit LazyBase(Handle coro) : _coro(coro) {}
-    LazyBase(LazyBase&& other) : _coro(std::move(other._coro)) {
+    explicit LazyBase(Handle coro) noexcept : _coro(coro) {}
+    LazyBase(LazyBase&& other) noexcept : _coro(std::move(other._coro)) {
         other._coro = nullptr;
     }
 
@@ -317,6 +358,10 @@ class LazyBase {
 
     template <typename F>
     void start(F&& callback) requires(std::is_invocable_v<F&&, Try<T>>) {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+
         // callback should take a single Try<T> as parameter, return value will
         // be ignored. a detached coroutine will not suspend at initial/final
         // suspend point.
@@ -345,11 +390,14 @@ class LazyBase {
     template <bool, template <typename> typename, typename...>
     friend struct detail::CollectAllVariadicAwaiter;
 
-    template <typename LazyType, typename IAlloc>
+    template <typename LazyType, typename IAlloc, typename Callback>
     friend struct detail::CollectAnyAwaiter;
 
     template <template <typename> typename LazyType, typename... Ts>
     friend struct detail::CollectAnyVariadicAwaiter;
+
+    template <typename... Ts>
+    friend struct detail::CollectAnyVariadicPairAwaiter;
 };
 
 }  // namespace detail
@@ -432,7 +480,8 @@ class LazyBase {
 // should implement `coAwait(Executor*)` member method. Then the caller would
 // pass its executor instance to the awaitable.
 template <typename T = void>
-class [[nodiscard]] Lazy : public detail::LazyBase<T, /*reschedule=*/false> {
+class [[nodiscard]] CORO_ONLY_DESTROY_WHEN_DONE ELIDEABLE_AFTER_AWAIT Lazy
+    : public detail::LazyBase<T, /*reschedule=*/false> {
     using Base = detail::LazyBase<T, false>;
 
 public:
@@ -443,7 +492,9 @@ class [[nodiscard]] Lazy : public detail::LazyBase<T, /*reschedule=*/false> {
     // via() called.
     RescheduleLazy<T> via(Executor* ex) && {
         logicAssert(this->_coro.operator bool(),
-                    "Lazy do not have a coroutine_handle");
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+
         this->_coro.promise()._executor = ex;
         return RescheduleLazy<T>(std::exchange(this->_coro, nullptr));
     }
@@ -454,12 +505,17 @@ class [[nodiscard]] Lazy : public detail::LazyBase<T, /*reschedule=*/false> {
     // for internal purpose only. See uthread/Await.h/await for details.
     Lazy<T> setEx(Executor* ex) && {
         logicAssert(this->_coro.operator bool(),
-                    "Lazy do not have a coroutine_handle");
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
         this->_coro.promise()._executor = ex;
         return Lazy<T>(std::exchange(this->_coro, nullptr));
     }
 
     auto coAwait(Executor* ex) {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+
         // derived lazy inherits executor
         this->_coro.promise()._executor = ex;
         return typename Base::ValueAwaiter(std::exchange(this->_coro, nullptr));
@@ -494,6 +550,14 @@ class [[nodiscard]] RescheduleLazy
         });
     }
 
+    RescheduleLazy<T> setLazyLocal(void* lazy_local) && {
+        logicAssert(this->_coro.operator bool(),
+                    "Lazy do not have a coroutine_handle "
+                    "Maybe the allocation failed or you're using a used Lazy");
+        this->_coro.promise()._lazy_local = lazy_local;
+        return RescheduleLazy<T>(std::exchange(this->_coro, nullptr));
+    }
+
     [[deprecated(
         "RescheduleLazy should be only allowed in DetachedCoroutine")]] auto
     operator co_await() {
@@ -513,6 +577,45 @@ inline Lazy<void> detail::LazyPromise<void>::get_return_object() noexcept {
     return Lazy<void>(Lazy<void>::Handle::from_promise(*this));
 }
 
+/// Why do we want to introduce `get_return_object_on_allocation_failure()`?
+/// Since a coroutine will be roughly converted to:
+///
+/// ```C++
+/// void *frame_addr = ::operator new(required size);
+/// __promise_ = new (frame_addr) __promise_type(...);
+/// __return_object_ = __promise_.get_return_object();
+/// co_await __promise_.initial_suspend();
+/// try {
+///     function-body
+/// } catch (...) {
+///     __promise_.unhandled_exception();
+/// }
+/// co_await __promise_.final_suspend();
+/// ```
+///
+/// Then we can find that the coroutine should be nounwind (noexcept) naturally
+/// if the constructor of the promise_type, the get_return_object() function,
+/// the initial_suspend, the unhandled_exception(), the final_suspend and the
+/// allocation function is noexcept.
+///
+/// For the specific coroutine type, Lazy, all the above except the allocation
+/// function is noexcept. So that we can make every Lazy function noexcept
+/// naturally if we make the allocation function nothrow. This is the reason why
+/// we want to introduce `get_return_object_on_allocation_failure()` to Lazy.
+///
+/// Note that the optimization may not work in some platforms due the ABI
+/// limitations. Since they need to consider the case that the destructor of an
+/// exception can throw exceptions.
+template <typename T>
+inline Lazy<T>
+detail::LazyPromise<T>::get_return_object_on_allocation_failure() noexcept {
+    return Lazy<T>(typename Lazy<T>::Handle(nullptr));
+}
+
+inline Lazy<void>
+detail::LazyPromise<void>::get_return_object_on_allocation_failure() noexcept {
+    return Lazy<void>(Lazy<void>::Handle(nullptr));
+}
 }  // namespace coro
 }  // namespace async_simple
 
diff --git a/include/async_simple/coro/ResumeBySchedule.h b/include/async_simple/coro/ResumeBySchedule.h
new file mode 100644
index 00000000..4d7e64d8
--- /dev/null
+++ b/include/async_simple/coro/ResumeBySchedule.h
@@ -0,0 +1,82 @@
+/*
+ * Copyright (c) 2022, Alibaba Group Holding Limited;
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#ifndef ASYNC_RESUME_BY_SCHEDULE_H
+#define ASYNC_RESUME_BY_SCHEDULE_H
+
+#include "async_simple/Executor.h"
+#include "async_simple/Future.h"
+#include "async_simple/coro/Lazy.h"
+#include "async_simple/experimental/coroutine.h"
+
+#include <type_traits>
+#include <utility>
+
+namespace async_simple::coro {
+
+namespace detail {
+
+template <typename T>
+class FutureResumeByScheduleAwaiter {
+public:
+    FutureResumeByScheduleAwaiter(Future<T>&& f) : _future(std::move(f)) {}
+
+    bool await_ready() { return _future.hasResult(); }
+
+    template <typename PromiseType>
+    void await_suspend(std::coroutine_handle<PromiseType> continuation) {
+        static_assert(std::is_base_of_v<LazyPromiseBase, PromiseType>,
+                      "FutureResumeByScheduleAwaiter is only allowed to be "
+                      "called by Lazy");
+        Executor* ex = continuation.promise()._executor;
+        _future.setContinuation([continuation, ex](Try<T>&& t) mutable {
+            if (ex != nullptr) {
+                ex->schedule(continuation);
+            } else {
+                continuation.resume();
+            }
+        });
+    }
+
+    auto await_resume() { return std::move(_future.value()); }
+
+private:
+    Future<T> _future;
+};
+
+template <typename T>
+class FutureResumeByScheduleAwaitable {
+public:
+    explicit FutureResumeByScheduleAwaitable(Future<T>&& f)
+        : _future(std::move(f)) {}
+
+    auto coAwait(Executor*) {
+        return FutureResumeByScheduleAwaiter(std::move(_future));
+    }
+
+private:
+    Future<T> _future;
+};
+
+}  // namespace detail
+
+template <typename T>
+inline auto ResumeBySchedule(Future<T>&& future) {
+    return detail::FutureResumeByScheduleAwaitable<T>(std::move(future));
+}
+
+}  // namespace async_simple::coro
+
+#endif
diff --git a/include/async_simple/coro/SharedMutex.h b/include/async_simple/coro/SharedMutex.h
index 9aac98fc..11785486 100644
--- a/include/async_simple/coro/SharedMutex.h
+++ b/include/async_simple/coro/SharedMutex.h
@@ -63,10 +63,10 @@ class SharedMutexBase {
     static constexpr unsigned max_readers = ~write_entered_flag;
 
     // Test whether the write-entered flag is set. mut_ must be locked.
-    bool write_entered() const { return state_ & write_entered_flag; }
+    bool write_entered() const noexcept { return state_ & write_entered_flag; }
 
     // The number of reader locks currently held. mut_ must be locked.
-    unsigned readers() const { return state_ & max_readers; }
+    unsigned readers() const noexcept { return state_ & max_readers; }
 
 public:
     template <typename... Args>
@@ -83,11 +83,14 @@ class SharedMutexBase {
     async_simple::coro::Lazy<> coLock() noexcept {
         auto scoper = co_await mut_.coScopedLock();
         // Wait until we can set the write-entered flag.
-
-        co_await gate1_.wait(mut_, [this] { return !write_entered(); });
+        if (write_entered()) {
+            co_await gate1_.wait(mut_, [this] { return !write_entered(); });
+        }
         state_ |= write_entered_flag;
         // Then wait until there are no more readers.
-        co_await gate2_.wait(mut_, [this] { return readers() == 0; });
+        if (readers() != 0) {
+            co_await gate2_.wait(mut_, [this] { return readers() == 0; });
+        }
     }
 
     bool tryLock() noexcept {
@@ -115,7 +118,9 @@ class SharedMutexBase {
 
     async_simple::coro::Lazy<void> coLockShared() {
         auto scoper = co_await mut_.coScopedLock();
-        co_await gate1_.wait(mut_, [this] { return state_ < max_readers; });
+        if (state_ >= max_readers) {
+            co_await gate1_.wait(mut_, [this] { return state_ < max_readers; });
+        }
         ++state_;
     }
 
diff --git a/include/async_simple/coro/ViaCoroutine.h b/include/async_simple/coro/ViaCoroutine.h
index 4c82a400..29066fa2 100644
--- a/include/async_simple/coro/ViaCoroutine.h
+++ b/include/async_simple/coro/ViaCoroutine.h
@@ -31,6 +31,7 @@
 #include "async_simple/coro/Traits.h"
 
 #include <atomic>
+#include <cassert>
 #include <mutex>
 #include <utility>
 
@@ -60,10 +61,7 @@ class ViaCoroutine {
                 auto& pr = h.promise();
                 // promise will remain valid across final_suspend point
                 if (pr._ex) {
-                    std::function<void()> func = [&pr]() {
-                        pr._continuation.resume();
-                    };
-                    pr._ex->checkin(func, _ctx);
+                    pr._ex->checkin(pr._continuation, _ctx);
                 } else {
                     pr._continuation.resume();
                 }
@@ -178,7 +176,8 @@ struct [[nodiscard]] ViaAsyncAwaiter {
 template <typename Awaitable>
 inline auto coAwait(Executor* ex, Awaitable&& awaitable) {
     if constexpr (detail::HasCoAwaitMethod<Awaitable>) {
-        return std::forward<Awaitable>(awaitable).coAwait(ex);
+        return detail::getAwaiter(
+            std::forward<Awaitable>(awaitable).coAwait(ex));
     } else {
         using AwaiterType =
             decltype(detail::getAwaiter(std::forward<Awaitable>(awaitable)));
diff --git a/include/async_simple/executors/SimpleExecutor.cpp b/include/async_simple/executors/SimpleExecutor.cpp
deleted file mode 100644
index 3e3bd037..00000000
--- a/include/async_simple/executors/SimpleExecutor.cpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright (c) 2022, Alibaba Group Holding Limited;
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#include "async_simple/executors/SimpleExecutor.h"
-
-namespace async_simple {
-
-namespace executors {
-
-// 0xBFFFFFFF == ~0x40000000
-static constexpr int64_t kContextMask = 0x40000000;
-
-SimpleExecutor::SimpleExecutor(size_t threadNum) : _pool(threadNum) {
-    _ioExecutor.init();
-}
-
-SimpleExecutor::~SimpleExecutor() { _ioExecutor.destroy(); }
-
-SimpleExecutor::Context SimpleExecutor::checkout() {
-    // avoid CurrentId equal to NULLCTX
-    return reinterpret_cast<Context>(_pool.getCurrentId() | kContextMask);
-}
-
-bool SimpleExecutor::checkin(Func func, Context ctx, ScheduleOptions opts) {
-    int64_t id = reinterpret_cast<int64_t>(ctx);
-    auto prompt = _pool.getCurrentId() == (id & (~kContextMask)) && opts.prompt;
-    if (prompt) {
-        func();
-        return true;
-    }
-    return _pool.scheduleById(std::move(func), id & (~kContextMask)) ==
-           util::ThreadPool::ERROR_NONE;
-}
-
-}  // namespace executors
-
-}  // namespace async_simple
diff --git a/include/async_simple/executors/SimpleExecutor.h b/include/async_simple/executors/SimpleExecutor.h
index fed2014e..8265c700 100644
--- a/include/async_simple/executors/SimpleExecutor.h
+++ b/include/async_simple/executors/SimpleExecutor.h
@@ -28,6 +28,9 @@ namespace async_simple {
 
 namespace executors {
 
+// 0xBFFFFFFF == ~0x40000000
+inline constexpr int64_t kContextMask = 0x40000000;
+
 // This is a simple executor. The intention of SimpleExecutor is to make the
 // test available and show how user should implement their executors. People who
 // want to have fun with async_simple could use SimpleExecutor for convenience,
@@ -43,8 +46,10 @@ class SimpleExecutor : public Executor {
     using Context = Executor::Context;
 
 public:
-    explicit SimpleExecutor(size_t threadNum);
-    ~SimpleExecutor();
+    explicit SimpleExecutor(size_t threadNum) : _pool(threadNum) {
+        _ioExecutor.init();
+    }
+    ~SimpleExecutor() { _ioExecutor.destroy(); }
 
 public:
     bool schedule(Func func) override {
@@ -58,8 +63,22 @@ class SimpleExecutor : public Executor {
 
     size_t currentContextId() const override { return _pool.getCurrentId(); }
 
-    Context checkout() override;
-    bool checkin(Func func, Context ctx, ScheduleOptions opts) override;
+    Context checkout() override {
+        // avoid CurrentId equal to NULLCTX
+        return reinterpret_cast<Context>(_pool.getCurrentId() | kContextMask);
+    }
+
+    bool checkin(Func func, Context ctx, ScheduleOptions opts) override {
+        int64_t id = reinterpret_cast<int64_t>(ctx);
+        auto prompt =
+            _pool.getCurrentId() == (id & (~kContextMask)) && opts.prompt;
+        if (prompt) {
+            func();
+            return true;
+        }
+        return _pool.scheduleById(std::move(func), id & (~kContextMask)) ==
+               util::ThreadPool::ERROR_NONE;
+    }
 
     IOExecutor* getIOExecutor() override { return &_ioExecutor; }
 
diff --git a/include/async_simple/executors/SimpleIOExecutor.h b/include/async_simple/executors/SimpleIOExecutor.h
index 9d0ae3d2..c316b53c 100644
--- a/include/async_simple/executors/SimpleIOExecutor.h
+++ b/include/async_simple/executors/SimpleIOExecutor.h
@@ -17,6 +17,11 @@
 #define FUTURE_SIMPLE_IO_EXECUTOR_H
 
 #include "async_simple/IOExecutor.h"
+
+#if !__has_include(<libaio.h>) && !defined(ASYNC_SIMPLE_HAS_NOT_AIO)
+#define ASYNC_SIMPLE_HAS_NOT_AIO
+#endif
+
 #ifndef ASYNC_SIMPLE_HAS_NOT_AIO
 #include <libaio.h>
 #endif
diff --git a/include/async_simple/uthread/internal/thread.cc b/include/async_simple/uthread/internal/thread.cc
index 3c58bee5..8cf90ae5 100644
--- a/include/async_simple/uthread/internal/thread.cc
+++ b/include/async_simple/uthread/internal/thread.cc
@@ -41,22 +41,22 @@ void __sanitizer_finish_switch_fiber(void* fake_stack_save,
                                      size_t* stack_size_old);
 }
 
-inline void start_switch_fiber(jmp_buf_link* context) {
-    __sanitizer_start_switch_fiber(&context->asan_fake_stack,
+inline void start_switch_fiber(jmp_buf_link* context, void **stack) {
+    __sanitizer_start_switch_fiber(stack,
                                    context->asan_stack_bottom,
                                    context->asan_stack_size);
 }
 
-inline void finish_switch_fiber(jmp_buf_link* context) {
-    __sanitizer_finish_switch_fiber(context->asan_fake_stack,
+inline void finish_switch_fiber(jmp_buf_link* context, void *stack) {
+    __sanitizer_finish_switch_fiber(stack,
                                     &context->asan_stack_bottom,
                                     &context->asan_stack_size);
 }
 
 #else
 
-inline void start_switch_fiber(jmp_buf_link* context) {}
-inline void finish_switch_fiber(jmp_buf_link* context) {}
+inline void start_switch_fiber(jmp_buf_link* context, void *stack) {}
+inline void finish_switch_fiber(jmp_buf_link* context, void *stack) {}
 
 #endif  // AS_INTERNAL_USE_ASAN
 
@@ -85,17 +85,19 @@ inline void jmp_buf_link::switch_in() {
     link = std::exchange(g_current_context, this);
     if (!link)
         AS_UNLIKELY { link = &g_unthreaded_context; }
-    start_switch_fiber(this);
+    void *stack_addr = nullptr;
+    start_switch_fiber(this, &stack_addr);
     // `thread` is currently only used in `s_main`
     fcontext = _fl_jump_fcontext(fcontext, thread).fctx;
-    finish_switch_fiber(this);
+    finish_switch_fiber(link, stack_addr);
 }
 
 inline void jmp_buf_link::switch_out() {
     g_current_context = link;
-    start_switch_fiber(link);
+    void *stack_addr = nullptr;
+    start_switch_fiber(link, &stack_addr);
     link->fcontext = _fl_jump_fcontext(link->fcontext, thread).fctx;
-    finish_switch_fiber(link);
+    finish_switch_fiber(this, stack_addr);
 }
 
 inline void jmp_buf_link::initial_switch_in_completed() {
@@ -143,7 +145,7 @@ void thread_context::setup() {
                                           stack_size_, thread_context::s_main);
     context_.thread = this;
 #ifdef AS_INTERNAL_USE_ASAN
-    context_.asan_stack_bottom = stack_.get();
+    context_.asan_stack_bottom = stack_.get() + stack_size_;
     context_.asan_stack_size = stack_size_;
 #endif
     context_.switch_in();
diff --git a/include/async_simple/uthread/internal/thread_impl.h b/include/async_simple/uthread/internal/thread_impl.h
index 5f7d3e7c..f3e4943d 100644
--- a/include/async_simple/uthread/internal/thread_impl.h
+++ b/include/async_simple/uthread/internal/thread_impl.h
@@ -49,7 +49,6 @@ struct jmp_buf_link {
 #ifdef AS_INTERNAL_USE_ASAN
     const void* asan_stack_bottom = nullptr;
     std::size_t asan_stack_size = 0;
-    void* asan_fake_stack = nullptr;
 #endif
 
 public:
diff --git a/include/async_simple/util/move_only_function.h b/include/async_simple/util/move_only_function.h
new file mode 100644
index 00000000..976b8572
--- /dev/null
+++ b/include/async_simple/util/move_only_function.h
@@ -0,0 +1,410 @@
+/*
+ * Copyright (c) 2022, Alibaba Group Holding Limited;
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* This file implements a simple condition variable. This is used as a
+ * low level component in async_simple. Users shouldn't use this directly.
+ */
+#ifndef ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
+#define ASYNC_SIMPLE_UTIL_MOVE_ONLY_FUNCTION_H
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <type_traits>
+
+namespace async_simple::util {
+
+template <typename Signature>
+class move_only_function;
+
+namespace detail {
+template <typename ResultType, typename RetType,
+          bool = std::is_void<RetType>::value, typename = void>
+struct RetTypeCheck : std::false_type {};
+
+template <typename ResultType, typename RetType>
+struct RetTypeCheck<ResultType, RetType, true,
+                    std::void_t<typename ResultType::type>> : std::true_type {};
+
+// check the implicit conversion to R.
+template <typename ResultType, typename RetType>
+struct RetTypeCheck<ResultType, RetType, false,
+                    std::void_t<typename ResultType::type>> : std::true_type {
+private:
+    static typename ResultType::type _S_get();
+
+    template <typename T>
+    static void _S_conv(T);
+
+    template <typename T, typename = decltype(_S_conv<T>(_S_get()))>
+    static std::true_type _S_test(int);
+
+    template <typename T>
+    static std::false_type _S_test(...);
+
+public:
+    using type = decltype(_S_test<RetType>(1));
+};
+
+class _undefined_class;
+
+// _no_copy_types 提供了可以容纳以下指针的满足size和alignment
+// requirement要求的内存区域 _no_copy_types provides a memory area that can
+// accommodate the following pointers and meets size and alignment requirements
+union _no_copy_types {
+    void* _m_object;
+    const void* _m_const_object;
+    void (*_m_function_pointer)();
+    void (_undefined_class::*_m_member_pointer)();
+};
+
+union [[gnu::may_alias]] _any_data {
+    void* _m_access() { return &_m_pod_data[0]; }
+
+    const void* _m_access() const { return &_m_pod_data[0]; }
+
+    template <typename T>
+    T& _m_access() {
+        return *static_cast<T*>(_m_access());
+    }
+
+    template <typename T>
+    const T& _m_access() const {
+        return *static_cast<const T*>(_m_access());
+    }
+
+    // _m_unused 要求编译器满足alignment requirement
+    // _m_unused requires the compiler to meet alignment requirements
+    _no_copy_types _m_unused;
+    char _m_pod_data[sizeof(_no_copy_types)];
+};
+
+enum class _manager_operation : uint8_t {
+    _destroy_functor,
+};
+
+class _function_base {
+public:
+    static constexpr size_t _m_max_size = sizeof(_no_copy_types);
+    static constexpr size_t _m_max_align = alignof(_no_copy_types);
+
+    template <typename Functor>
+    class _base_manager {
+    protected:
+        static const bool _stored_locally =
+            std::is_trivially_copyable_v<Functor> &&
+            sizeof(Functor) <= _m_max_size &&
+            alignof(Functor) <= _m_max_align &&
+            (_m_max_align % alignof(Functor) == 0);
+
+        // 当_local_storage()为true时，在预分配的栈空间_any_data中存储Functor，否则在堆上存储Functor，_any_data中存储指向Functor的指针
+        // When _local_storage() == true, store the Functor in the pre-allocated
+        // stack space _any_data. Otherwise store the Functor on the heap space
+        // and store a pointer to the Functor in _any_data
+        typedef std::integral_constant<bool, _stored_locally> _local_storage;
+
+        static Functor* _m_get_pointer(const _any_data& _source) {
+            if constexpr (_stored_locally) {
+                const Functor& f = _source._m_access<Functor>();
+                return const_cast<Functor*>(std::addressof(f));
+            }
+            return _source._m_access<Functor*>();
+        }
+
+        static void _m_destroy(_any_data& _victim,
+                               /*Local Storage*/ std::true_type) {
+            _victim._m_access<Functor>().~Functor();
+        }
+
+        static void _m_destroy(_any_data& _victim,
+                               /*Local Storage*/ std::false_type) {
+            delete _victim._m_access<Functor*>();
+        }
+
+    public:
+        static void _m_manager(_any_data& _dest, const _any_data& _source,
+                               _manager_operation _op) {
+            switch (_op) {
+                case _manager_operation::_destroy_functor:
+                    _m_destroy(_dest, _local_storage());
+                    break;
+            }
+        }
+
+        static void _m_init_functor(_any_data& _functor, Functor&& _f) {
+            _m_init_functor(_functor, std::move(_f), _local_storage());
+        }
+
+        static void _m_init_functor(_any_data& _functor, const Functor& _f) {
+            _m_init_functor(_functor, _f, _local_storage());
+        }
+
+        template <typename Signature>
+        static bool _m_not_empty_function(
+            const move_only_function<Signature>& f) {
+            return static_cast<bool>(f);
+        }
+
+        template <typename T>
+        static bool _m_not_empty_function(T* fp) {
+            return fp != nullptr;
+        }
+
+        template <typename Class, typename T>
+        static bool _m_not_empty_function(T Class::*mp) {
+            return mp != nullptr;
+        }
+
+        template <typename T>
+        static bool _m_not_empty_function(const T&) {
+            return true;
+        }
+
+    private:
+        static void _m_init_functor(_any_data& functor, Functor&& f,
+                                    /*Local Storage*/ std::true_type) {
+            ::new (functor._m_access()) Functor(std::move(f));
+        }
+
+        static void _m_init_functor(_any_data& functor, Functor&& f,
+                                    /*Local Storage*/ std::false_type) {
+            functor._m_access<Functor*>() = new Functor(std::move(f));
+        }
+
+        static void _m_init_functor(_any_data& functor, const Functor& f,
+                                    /*Local Storage*/ std::true_type) {
+            ::new (functor._m_access()) Functor(f);
+        }
+
+        static void _m_init_functor(_any_data& functor, const Functor& f,
+                                    /*Local Storage*/ std::false_type) {
+            functor._m_access<Functor*>() = new Functor(f);
+        }
+    };
+
+    _function_base() : _m_manager(nullptr) {}
+
+    ~_function_base() {
+        if (_m_manager) {
+            _m_manager(_m_functor, _m_functor,
+                       _manager_operation::_destroy_functor);
+        }
+    }
+
+    bool _m_empty() const { return !_m_manager; }
+
+    using manager_type = void (*)(_any_data&, const _any_data&,
+                                  _manager_operation);
+
+    _any_data _m_functor;
+    manager_type _m_manager;
+};
+
+template <typename Signature, typename Functor>
+class FunctionHandler;
+
+template <typename Res, typename Functor, typename... ArgTypes>
+class FunctionHandler<Res(ArgTypes...), Functor>
+    : public _function_base::_base_manager<Functor> {
+    using BaseType = _function_base::_base_manager<Functor>;
+
+public:
+    static void _m_manager(_any_data& _dest, const _any_data& _source,
+                           _manager_operation _op) {
+        return BaseType::_m_manager(_dest, _source, _op);
+    }
+
+    static Res _m_invoke(const _any_data& _functor, ArgTypes&&... _args) {
+        if constexpr (std::is_same_v<Res, void>) {
+            std::invoke(*BaseType::_m_get_pointer(_functor),
+                        std::forward<ArgTypes>(_args)...);
+        } else {
+            return std::invoke(*BaseType::_m_get_pointer(_functor),
+                               std::forward<ArgTypes>(_args)...);
+        }
+    }
+};
+
+// Specialization for invalid types
+template <>
+class FunctionHandler<void, void> {
+public:
+    static void _m_manager(_any_data&, const _any_data&, _manager_operation) {
+        return;
+    }
+};
+}  // namespace detail
+
+template <typename RetType, typename... ArgTypes>
+class move_only_function<RetType(ArgTypes...)>
+    : private detail::_function_base {
+    template <typename Func,
+              typename Res2 = std::invoke_result<Func, ArgTypes...>>
+    struct NotMoveOnlyCallable
+        : public detail::RetTypeCheck<Res2, RetType>::type {};
+
+    template <typename T>
+    struct NotMoveOnlyCallable<move_only_function, T> : public std::false_type {
+    };
+
+    template <typename T>
+    struct IsCStyleFunction : public std::false_type {};
+
+    template <typename Ret, typename... Args>
+    struct IsCStyleFunction<Ret (&)(Args...)> : public std::true_type {};
+
+    template <typename Cond, typename T>
+    using Requires = typename std::enable_if<Cond::value, T>::type;
+
+public:
+    using result_type = RetType;
+
+    // Default construct creates an empty function call wrapper.
+    move_only_function() noexcept : _function_base() {}
+
+    move_only_function(std::nullptr_t) noexcept : _function_base() {}
+
+    // delete copy constructor
+    move_only_function(const move_only_function&) = delete;
+
+    move_only_function(move_only_function&& other) noexcept : _function_base() {
+        other.swap(*this);
+    }
+
+    template <
+        typename Functor,
+        typename =
+            Requires<std::negation<std::is_same<
+                         std::remove_reference_t<Functor>, move_only_function>>,
+                     void>,
+        typename = Requires<std::negation<IsCStyleFunction<Functor>>, void>,
+        typename = Requires<NotMoveOnlyCallable<Functor>, void>>
+    move_only_function(Functor&& f) : _function_base() {
+        using MyHandler =
+            detail::FunctionHandler<RetType(ArgTypes...),
+                                    std::remove_reference_t<Functor>>;
+        if (MyHandler::_m_not_empty_function(f)) {
+            MyHandler::_m_init_functor(_m_functor, std::forward<Functor>(f));
+            _m_invoker = &MyHandler::_m_invoke;
+            _m_manager = &MyHandler::_m_manager;
+        }
+    }
+
+    // fix error: invalid application of 'sizeof' to a function type
+    // [-Werror=pointer-arith]
+    template <typename Res, typename... Args>
+    move_only_function(Res (&f)(Args...)) : _function_base() {
+        using MyHandler =
+            detail::FunctionHandler<RetType(ArgTypes...), Res (*)(Args...)>;
+        if (MyHandler::_m_not_empty_function(&f)) {
+            MyHandler::_m_init_functor(_m_functor, &f);
+            _m_invoker = &MyHandler::_m_invoke;
+            _m_manager = &MyHandler::_m_manager;
+        }
+    }
+
+    move_only_function& operator=(const move_only_function&) = delete;
+
+    move_only_function& operator=(move_only_function&& other) noexcept {
+        move_only_function(std::move(other)).swap(*this);
+        return *this;
+    }
+
+    move_only_function& operator=(std::nullptr_t) noexcept {
+        if (_m_manager) {
+            _m_manager(_m_functor, _m_functor,
+                       detail::_manager_operation::_destroy_functor);
+            _m_manager = nullptr;
+            _m_invoker = nullptr;
+        }
+        return *this;
+    }
+
+    template <typename Functor>
+    Requires<NotMoveOnlyCallable<typename std::decay<Functor>::type>,
+             move_only_function&>
+    operator=(Functor&& f) {
+        move_only_function(std::forward<Functor>(f)).swap(*this);
+        return *this;
+    }
+
+    void swap(move_only_function& other) noexcept {
+        std::swap(_m_functor, other._m_functor);
+        std::swap(_m_manager, other._m_manager);
+        std::swap(_m_invoker, other._m_invoker);
+    }
+
+    explicit operator bool() const noexcept { return !_m_empty(); }
+
+    RetType operator()(ArgTypes... _args) const {
+        if (_m_empty()) {
+            throw std::bad_function_call();
+        }
+        return _m_invoker(_m_functor, std::forward<ArgTypes>(_args)...);
+    }
+
+private:
+    using InvokerType = RetType (*)(const detail::_any_data&, ArgTypes&&...);
+    InvokerType _m_invoker;
+};
+
+namespace detail {
+
+template <typename>
+struct _move_only_function_guide_helper {};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...)> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...)&> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...) const> {
+    using type = Res(Args...);
+};
+
+template <typename Res, typename T, typename... Args>
+struct _move_only_function_guide_helper<Res (T::*)(Args...) const&> {
+    using type = Res(Args...);
+};
+
+}  // namespace detail
+
+template <
+    typename Functor,
+    typename Signature = typename detail::_move_only_function_guide_helper<
+        decltype(&Functor::operator())>::type>
+move_only_function(Functor) -> move_only_function<Signature>;
+
+template <typename Res, typename... Args>
+inline void swap(move_only_function<Res(Args...)>& _x,
+                 move_only_function<Res(Args...)>& _y) noexcept {
+    _x.swap(_y);
+}
+
+template <typename Res, typename... Args>
+inline bool operator==(const move_only_function<Res(Args...)>& f,
+                       std::nullptr_t) noexcept {
+    return !static_cast<bool>(f);
+}
+
+}  // namespace async_simple::util
+
+#endif