删减无关内容

module/Local_Server/Data_Feed/Data_Feed.cpp

@@ -10,15 +10,15 @@ bool Data_Feed::registered() {
     return false;
 }
 void Data_Feed_UDP_Server::handle_in_loop()  {
-    ucoro::sync_await(handle_in_loop_coro());
+    psco::sync_await(handle_in_loop_coro());
 }
 
-ucoro::awaitable<void> Data_Feed_UDP_Server::handle_in_loop_coro() {
+psco::awaitable<void> Data_Feed_UDP_Server::handle_in_loop_coro() {
     co_await svr.tick_coro();
     co_return;
 }
 
-ucoro::awaitable<void> Data_Feed_UDP_Server::send_coro(const std::string& data) {
+psco::awaitable<void> Data_Feed_UDP_Server::send_coro(const std::string& data) {
     co_await svr.write_to_all_clients_coro(data);
     co_return;
 }

module/Local_Server/Data_Feed/Data_Feed.h

@@ -47,6 +47,7 @@ struct Output_Format {
 class Data_Feed {
 public:
     virtual ~Data_Feed() = default;
+    std::unique_ptr<psco::awaitable<void>> loop_task;
     BIN_Msg_Buffer msg_buffer{};
     std::string key;
     bool enable = false;
@@ -56,11 +57,11 @@ public:
     virtual void handle_in_loop() {
 
     }
-    virtual ucoro::awaitable<void> handle_in_loop_coro() {
+    virtual psco::awaitable<void> handle_in_loop_coro() {
         handle_in_loop();
         co_return;
     }
-    virtual ucoro::awaitable<void> send_coro(const std::string&) {
+    virtual psco::awaitable<void> send_coro(const std::string&) {
         co_return;
     }
     virtual Psc::JSON to_json() {
@@ -135,14 +136,14 @@ public:
     ~Data_Feed_TCP_Server() override {}
     void handle_in_loop() override {
         //std::cout << socket.to_string() << "flush_clients" << std::endl;
-        ucoro::sync_await(handle_in_loop_coro());
+        psco::sync_await(handle_in_loop_coro());
     }
-    ucoro::awaitable<void> handle_in_loop_coro() override {
+    psco::awaitable<void> handle_in_loop_coro() override {
         co_await svr.flush_clients_coro();
         co_await svr.tick_coro();
         co_return;
     }
-    ucoro::awaitable<void> send_coro(const std::string& data) override {
+    psco::awaitable<void> send_coro(const std::string& data) override {
         co_await svr.write_to_all_clients_coro(data);
         co_return;
     }
@@ -165,7 +166,7 @@ public:
         svr.set_connect_system_buffer_size(connect_system_buffer_size);
         svr.set_tcp_no_delay(false);
         svr.create();
-        return ucoro::sync_await(svr.listen_coro("0.0.0.0", port));
+        return psco::sync_await(svr.listen_coro("0.0.0.0", port));
     }
     Psc::JSON get_clients_json() {
         Psc::JSON ret = Psc::JSON::array();
@@ -202,13 +203,13 @@ public:
 class Data_Feed_TCP_Client : public Data_Feed {
 public:
     void handle_in_loop() override {
-        ucoro::sync_await(handle_in_loop_coro());
+        psco::sync_await(handle_in_loop_coro());
     }
-    ucoro::awaitable<void> handle_in_loop_coro() override {
+    psco::awaitable<void> handle_in_loop_coro() override {
         co_await cli.tick_coro();
         co_return;
     }
-    ucoro::awaitable<void> send_coro(const std::string& data) override {
+    psco::awaitable<void> send_coro(const std::string& data) override {
         co_await cli.send_coro(data);
         co_return;
     }
@@ -227,7 +228,7 @@ public:
         sockaddr_in.port = port;
         cli.set_dest_address(sockaddr_in);
         cli.create();
-        ucoro::sync_await(cli.connect_coro());
+        psco::sync_await(cli.connect_coro());
         return true;
     }
     void from_json(const Psc::JSON* that_json) override {
@@ -257,8 +258,8 @@ public:
     Data_Feed_UDP_Server()= default;
     ~Data_Feed_UDP_Server() override = default;
     void handle_in_loop() override;
-    ucoro::awaitable<void> handle_in_loop_coro() override;
+    psco::awaitable<void> handle_in_loop_coro() override;
-    ucoro::awaitable<void> send_coro(const std::string& data) override;
+    psco::awaitable<void> send_coro(const std::string& data) override;
     [[nodiscard]] Psc::JSON get_clients_json() const {
         Psc::JSON ret = Psc::JSON::array();
         for (const auto& i : svr.clients) {
@@ -295,13 +296,13 @@ public:
         return VAR_JSON_1(state);
     }
     void handle_in_loop() override {
-        ucoro::sync_await(handle_in_loop_coro());
+        psco::sync_await(handle_in_loop_coro());
     }
-    ucoro::awaitable<void> handle_in_loop_coro() override {
+    psco::awaitable<void> handle_in_loop_coro() override {
         co_await cli.tick_coro();
         co_return;
     }
-    ucoro::awaitable<void> send_coro(const std::string& data) override {
+    psco::awaitable<void> send_coro(const std::string& data) override {
         co_await cli.send_coro(data);
         co_return;
     }
@@ -326,7 +327,7 @@ public:
     bool _open() override {
         cli.create();
         cli.set_dest_address(url, port);
-        ucoro::sync_await(cli.connect_coro());
+        psco::sync_await(cli.connect_coro());
         return true;
     }
 };

module/Local_Server/Data_Source/Data_Source.h

@@ -68,8 +68,9 @@ protected:
 class Data_Source : public std::enable_shared_from_this<Data_Source>, public Data_Source_Handler {
 public:
     ~Data_Source() override = default;
+    std::unique_ptr<psco::awaitable<void>> loop_task;
     std::shared_ptr<Data_Source> that();
-    virtual ucoro::awaitable<std::string> read_coro() {co_return "";};
+    virtual psco::awaitable<std::string> read_coro() {co_return "";};
     bool registered() const;
     virtual Psc::JSON get_custom_state_json() = 0;
     Psc::JSON get_state();
@@ -77,7 +78,7 @@ public:
     // std::shared_ptr<Input_Format> parse_format;
     Data_Source();
     std::shared_ptr<SSR::Mode_Msg> last_prase_msg = nullptr;
-    virtual ucoro::awaitable<void> handle_in_loop_coro(){co_return;}
+    virtual psco::awaitable<void> handle_in_loop_coro(){co_return;}
     std::atomic<bool>      enable{};
     std::string            type;
     std::atomic<bool>      base_station_show{};
@@ -166,7 +167,7 @@ protected:
 
 
 struct TCP_Client_Data_Source : Data_Source {
-    ucoro::awaitable<void> handle_in_loop_coro() override {
+    psco::awaitable<void> handle_in_loop_coro() override {
         co_await cli.tick_coro();
         co_return;
     }
@@ -189,7 +190,7 @@ struct TCP_Client_Data_Source : Data_Source {
 
         cli.set_dest_address(addr);
         cli.create();
-        ucoro::sync_await(cli.connect_coro());
+        psco::sync_await(cli.connect_coro());
         return true;
     }
     void     _close() override { cli.close(); }
@@ -207,7 +208,7 @@ struct TCP_Client_Data_Source : Data_Source {
     }
 
 
-    ucoro::awaitable<std::string> read_coro() override {
+    psco::awaitable<std::string> read_coro() override {
         co_return co_await cli.read_coro();
     }
 };
@@ -237,13 +238,13 @@ struct Serial_Data_Source : Data_Source {
     }
     void        _close() override { if (serial) serial->close(); }
 
-    ucoro::awaitable<void> handle_in_loop_coro() override {
+    psco::awaitable<void> handle_in_loop_coro() override {
         if (serial) {
             co_await serial->tick_coro();
         }
         co_return;
     }
-    ucoro::awaitable<std::string> read_coro() override {
+    psco::awaitable<std::string> read_coro() override {
         if (!serial) {
             co_return "";
         }

module/Local_Server/External_Database/External_Database.cpp

@@ -67,10 +67,10 @@ namespace
     }
 
     template <typename T, typename Starter>
-    ucoro::awaitable<T> await_external_database_callback(Starter starter)
+    psco::awaitable<T> await_external_database_callback(Starter starter)
     {
-        using Result = ucoro::traits::exception_with_result_t<T>;
+        using Result = psco::traits::exception_with_result_t<T>;
-        auto result = co_await ucoro::callback_awaitable<Result>(
+        auto result = co_await psco::callback_awaitable<Result>(
             [starter = std::move(starter)](auto handler) mutable
             {
                 starter([handler = std::move(handler)](std::exception_ptr exception,
@@ -494,7 +494,7 @@ void External_Resources_Manager::async_external_database_status(
         std::move(callback));
 }
 
-ucoro::awaitable<std::vector<External_Resource_Status>>
+psco::awaitable<std::vector<External_Resource_Status>>
 External_Resources_Manager::refresh_external_databases_coro(
     const bool force_download)
 {
@@ -506,7 +506,7 @@ External_Resources_Manager::refresh_external_databases_coro(
         });
 }
 
-ucoro::awaitable<External_Resource_Status>
+psco::awaitable<External_Resource_Status>
 External_Resources_Manager::refresh_external_database_coro(
     std::string resource_name,
     const bool force_download)
@@ -521,7 +521,7 @@ External_Resources_Manager::refresh_external_database_coro(
         });
 }
 
-ucoro::awaitable<External_Resource_Status>
+psco::awaitable<External_Resource_Status>
 External_Resources_Manager::import_external_database_coro(
     std::string resource_name,
     std::filesystem::path source_file)
@@ -536,7 +536,7 @@ External_Resources_Manager::import_external_database_coro(
         });
 }
 
-ucoro::awaitable<External_Resource_Status>
+psco::awaitable<External_Resource_Status>
 External_Resources_Manager::clear_external_database_table_coro(
     std::string resource_name)
 {
@@ -548,7 +548,7 @@ External_Resources_Manager::clear_external_database_table_coro(
         });
 }
 
-ucoro::awaitable<std::optional<External_Database_Row>>
+psco::awaitable<std::optional<External_Database_Row>>
 External_Resources_Manager::query_external_database_coro(
     std::string resource_name,
     std::vector<std::string> primary_key_values) const
@@ -566,7 +566,7 @@ External_Resources_Manager::query_external_database_coro(
         });
 }
 
-ucoro::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
+psco::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
 External_Resources_Manager::query_aircraft_external_databases_coro(
     std::string icao24) const
 {
@@ -579,7 +579,7 @@ External_Resources_Manager::query_aircraft_external_databases_coro(
         });
 }
 
-ucoro::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
+psco::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
 External_Resources_Manager::query_callsign_external_databases_coro(
     std::optional<std::string> callsign) const
 {
@@ -592,7 +592,7 @@ External_Resources_Manager::query_callsign_external_databases_coro(
         });
 }
 
-ucoro::awaitable<std::vector<External_Resource_Status>>
+psco::awaitable<std::vector<External_Resource_Status>>
 External_Resources_Manager::external_database_status_coro() const
 {
     co_return co_await await_external_database_callback<std::vector<External_Resource_Status>>

module/Local_Server/External_Database/global.h

@@ -1,8 +1,5 @@
 #pragma once
-
-#include "../../../../../core_library/Core/Core/Base/JSON.h"
 #include <SQLiteCpp/Database.h>
-
 #include <cstddef>
 #include <cstdint>
 #include <ctime>
@@ -15,7 +12,9 @@
 #include <optional>
 #include <string>
 #include <vector>
-#include <ucoro/awaitable.hpp>
+#include <psco/awaitable.hpp>
+#include "Core/Base/JSON.h"
+
 
 class Global;
 
@@ -150,24 +149,24 @@ public:
                                                 Row_Map_Callback callback) const;
     void async_external_database_status(Status_List_Callback callback) const;
 
-    [[nodiscard]] ucoro::awaitable<std::vector<External_Resource_Status>>
+    [[nodiscard]] psco::awaitable<std::vector<External_Resource_Status>>
     refresh_external_databases_coro(bool force_download = true);
-    [[nodiscard]] ucoro::awaitable<External_Resource_Status>
+    [[nodiscard]] psco::awaitable<External_Resource_Status>
     refresh_external_database_coro(std::string resource_name,
                                    bool force_download = true);
-    [[nodiscard]] ucoro::awaitable<External_Resource_Status>
+    [[nodiscard]] psco::awaitable<External_Resource_Status>
     import_external_database_coro(std::string resource_name,
                                   std::filesystem::path source_file);
-    [[nodiscard]] ucoro::awaitable<External_Resource_Status>
+    [[nodiscard]] psco::awaitable<External_Resource_Status>
     clear_external_database_table_coro(std::string resource_name);
-    [[nodiscard]] ucoro::awaitable<std::optional<External_Database_Row>>
+    [[nodiscard]] psco::awaitable<std::optional<External_Database_Row>>
     query_external_database_coro(std::string resource_name,
                                  std::vector<std::string> primary_key_values) const;
-    [[nodiscard]] ucoro::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
+    [[nodiscard]] psco::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
     query_aircraft_external_databases_coro(std::string icao24) const;
-    [[nodiscard]] ucoro::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
+    [[nodiscard]] psco::awaitable<std::map<std::string, std::shared_ptr<External_Database_Row>>>
     query_callsign_external_databases_coro(std::optional<std::string> callsign) const;
-    [[nodiscard]] ucoro::awaitable<std::vector<External_Resource_Status>>
+    [[nodiscard]] psco::awaitable<std::vector<External_Resource_Status>>
     external_database_status_coro() const;
 
     void register_external_resource(std::unique_ptr<External_Resources> external_res);

module/Local_Server/server/Ucoro_Drogon_Glue.h

@@ -1,9 +1,7 @@
 #pragma once
-
 #include <drogon/drogon.h>
 #include <trantor/net/EventLoop.h>
-#include <ucoro/awaitable.hpp>
+#include <psco/awaitable.hpp>
-
 #include <coroutine>
 #include <exception>
 #include <memory>
@@ -11,119 +9,119 @@
 #include <type_traits>
 #include <utility>
 #include <variant>
-
 namespace Ecap_Coro {
-
 template <typename T>
 class Ucoro_Drogon_Awaiter {
 public:
-    explicit Ucoro_Drogon_Awaiter(ucoro::awaitable<T>&& task)
+    explicit Ucoro_Drogon_Awaiter(psco::awaitable<T>&& task)
-        : state_(std::make_shared<State>()), task_(std::move(task)) {}
+        : state_(std::make_shared<State>()), task_(std::move(task)) {
-
+    }
-    bool await_ready() const noexcept { return false; }
+    bool await_ready() const noexcept {
-
+        return false;
+    }
     void await_suspend(std::coroutine_handle<> continuation) {
         state_->continuation = continuation;
         state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
         if (state_->loop == nullptr) {
             state_->loop = drogon::app().getLoop();
         }
-
         auto state = state_;
         state_->running_task.emplace(
-            std::move(task_).detach_with_callback(
+            psco::with_callback(
-                [state](ucoro::traits::exception_with_result_t<T> result) mutable {
+                std::move(task_),
+                [state](psco::traits::exception_with_result_t<T> result) mutable {
                     state->result = std::move(result);
-                    auto resume = [state]() { state->continuation.resume(); };
+                    auto resume = [state]() {
+                        state->continuation.resume();
+                    };
                     if (state->loop != nullptr) {
                         state->loop->queueInLoop(std::move(resume));
                     } else {
                         resume();
                     }
-                }));
+                }
+            )
+        );
         state_->running_task->start();
     }
-
     T await_resume() {
         if (std::holds_alternative<std::exception_ptr>(state_->result)) {
-            std::rethrow_exception(std::get<std::exception_ptr>(state_->result));
+            auto exception = std::get<std::exception_ptr>(state_->result);
+            if (exception) {
+                std::rethrow_exception(exception);
+            }
         }
         return std::move(std::get<T>(state_->result));
     }
-
 private:
     struct State {
         trantor::EventLoop* loop{};
         std::coroutine_handle<> continuation{};
-        ucoro::traits::exception_with_result_t<T> result{};
+        psco::traits::exception_with_result_t<T> result{};
-        std::optional<ucoro::awaitable<void>> running_task{};
+        std::optional<psco::awaitable<void>> running_task{};
     };
-
     std::shared_ptr<State> state_;
-    ucoro::awaitable<T> task_;
+    psco::awaitable<T> task_;
 };
-
 template <>
 class Ucoro_Drogon_Awaiter<void> {
 public:
-    explicit Ucoro_Drogon_Awaiter(ucoro::awaitable<void>&& task)
+    explicit Ucoro_Drogon_Awaiter(psco::awaitable<void>&& task)
-        : state_(std::make_shared<State>()), task_(std::move(task)) {}
+        : state_(std::make_shared<State>()), task_(std::move(task)) {
-
+    }
-    bool await_ready() const noexcept { return false; }
+    bool await_ready() const noexcept {
-
+        return false;
+    }
     void await_suspend(std::coroutine_handle<> continuation) {
         state_->continuation = continuation;
         state_->loop = trantor::EventLoop::getEventLoopOfCurrentThread();
         if (state_->loop == nullptr) {
             state_->loop = drogon::app().getLoop();
         }
-
         auto state = state_;
         state_->running_task.emplace(
-            std::move(task_).detach_with_callback(
+            psco::with_callback(
+                std::move(task_),
                 [state](std::exception_ptr exception) mutable {
                     state->exception = exception;
-                    auto resume = [state]() { state->continuation.resume(); };
+                    auto resume = [state]() {
+                        state->continuation.resume();
+                    };
                     if (state->loop != nullptr) {
                         state->loop->queueInLoop(std::move(resume));
                     } else {
                         resume();
                     }
-                }));
+                }
+            )
+        );
         state_->running_task->start();
     }
-
     void await_resume() {
         if (state_->exception) {
             std::rethrow_exception(state_->exception);
         }
     }
-
 private:
     struct State {
         trantor::EventLoop* loop{};
         std::coroutine_handle<> continuation{};
         std::exception_ptr exception{};
-        std::optional<ucoro::awaitable<void>> running_task{};
+        std::optional<psco::awaitable<void>> running_task{};
     };
-
     std::shared_ptr<State> state_;
-    ucoro::awaitable<void> task_;
+    psco::awaitable<void> task_;
 };
-
 template <typename T>
-auto to_drogon(ucoro::awaitable<T>&& task) {
+auto to_drogon(psco::awaitable<T>&& task) {
     return Ucoro_Drogon_Awaiter<T>{std::move(task)};
 }
-
 template <typename T>
-drogon::Task<T> to_drogon_task(ucoro::awaitable<T>&& task) {
+drogon::Task<T> to_drogon_task(psco::awaitable<T>&& task) {
     co_return co_await to_drogon(std::move(task));
 }
-
+inline drogon::Task<> to_drogon_task(psco::awaitable<void>&& task) {
-inline drogon::Task<> to_drogon_task(ucoro::awaitable<void>&& task) {
     co_await to_drogon(std::move(task));
     co_return;
 }
-
+}
-}  // namespace Ecap_Coro

module/Local_Server/server/io_coro.cpp

@@ -1,93 +1,72 @@
 #include "../server/Global.h"
 #include "../server/Mode_Msg_Buffer.h"
+#include "psco/single_thread.h"
 #include <atomic>
 #include <chrono>
-#include <condition_variable>
+#include <exception>
-#include <functional>
-#include <future>
 #include <iostream>
-#include <map>
+#include <memory>
-#include <mutex>
-#include <queue>
 #include <sstream>
-#include <thread>
+#include <utility>
 #include <vector>
-#include "ucoro/single_thread.h"
+
-bool is_ucoro_operation_cancelled(std::exception_ptr exception) noexcept {
-    if (!exception) {
-        return false;
-    }
-    try {
-        std::rethrow_exception(exception);
-    }
-    catch (const ucoro::operation_cancelled&) {
-        return true;
-    }
-    catch (...) {
-        return false;
-    }
-}
 Frequency_Limit too_many_msg_limit;
 Frequency_Limit flush_limit;
 namespace {
-    ucoro::Single_Thread_Scheduler& data_feed_thread_scheduler() {
+    psco::Single_Thread_Scheduler& data_feed_thread_scheduler() {
-        static ucoro::Single_Thread_Scheduler scheduler;
+        static psco::Single_Thread_Scheduler scheduler;
         return scheduler;
     }
-    ucoro::awaitable<void> data_feed_thread_yield_coro() {
+    psco::awaitable<void> data_feed_thread_yield_coro() {
-        co_await ucoro::callback_awaitable<void>([](auto done) mutable {
+        co_await psco::callback_awaitable<void>([](auto done) mutable {
-            data_feed_thread_scheduler().post(
+            data_feed_thread_scheduler().post([done = std::move(done)]() mutable {
-                [done = std::move(done)]() mutable {
                 done();
-                }
-            );
             });
+        });
+        co_return;
     }
-    ucoro::awaitable<void> data_feed_thread_wait_event_coro() {
+    psco::awaitable<void> data_feed_thread_wait_event_coro() {
-        co_await ucoro::callback_awaitable<void>([](auto done) mutable {
+        co_await psco::callback_awaitable<void>([](auto done) mutable {
-            data_feed_thread_scheduler().async_wait(
+            data_feed_thread_scheduler().async_wait([done = std::move(done)]() mutable {
-                [done = std::move(done)]() mutable {
                 done();
-                }
-            );
             });
+        });
+        co_return;
+    }
+    psco::awaitable<void> data_source_loop_coro(std::atomic<bool>& running, std::weak_ptr<Data_Source> source_ref) {
+        while (running.load(std::memory_order_acquire)) {
+            auto source = source_ref.lock();
+            if (!source || !source->enable || !source->registered()) {
+                break;
             }
-    ucoro::awaitable<void> data_source_loop_coro(
-        std::atomic<bool>& running,
-        std::shared_ptr<Data_Source> source
-    ) {
-        while (running.load(std::memory_order_acquire) &&
-            source &&
-            source->enable &&
-            source->registered()) {
             if (!source->is_open() && !source->open()) {
+                source.reset();
                 co_await data_feed_thread_wait_event_coro();
                 continue;
             }
             co_await source->handle_in_loop_coro();
             auto mode_data = co_await source->read_coro();
-            if (!running.load(std::memory_order_acquire) ||
+            if (!running.load(std::memory_order_acquire) || !source->enable || !source->registered()) {
-                !source->enable ||
-                !source->registered()) {
                 break;
             }
             source->process_mode_acs_data(mode_data);
+            source.reset();
             co_await data_feed_thread_yield_coro();
         }
         co_return;
     }
-    ucoro::awaitable<void> data_feed_loop_coro(
+    psco::awaitable<void> data_feed_loop_coro(std::atomic<bool>& running, std::weak_ptr<Data_Feed> feed_ref) {
-        std::atomic<bool>& running,
-        std::shared_ptr<Data_Feed> feed
-    ) {
         auto& mode_acs = Global::instance()->mode_acs;
         auto& cfg = mode_acs.data_feed_config;
         auto& pool = cfg.pool_;
         auto& report_data_feed_msg_mum = mode_acs.report_data_feed_msg_mum;
-        while (running.load(std::memory_order_acquire) &&
+        while (running.load(std::memory_order_acquire)) {
-            feed &&
+            std::vector<std::string> messages;
-            feed->enable &&
+            {
-            feed->registered()) {
+                auto feed = feed_ref.lock();
+                if (!feed || !feed->enable || !feed->registered()) {
+                    break;
+                }
                 co_await feed->handle_in_loop_coro();
                 auto s_num = feed->msg_buffer.mode_s_msg_num.load();
                 auto other_num = feed->msg_buffer.mode_other_msg_num.load();
@@ -95,198 +74,164 @@ namespace {
                 Pool_Guard pg(&pool, all);
                 auto num = report_data_feed_msg_mum.load();
                 auto monitor_msg_live = mode_acs.monitor_msg_live.load();
-            if (monitor_msg_live) {
+                if (monitor_msg_live && num != 0 && all.size() > num && too_many_msg_limit.test()) {
-                if (num != 0 && all.size() > num) {
-                    if (too_many_msg_limit.test()) {
                     std::ostringstream oss;
                     oss << "feed_key:" << feed->key << "   ";
                     oss << "recv_s:" << s_num << "   ";
                     oss << "recv_other:" << other_num << "   ";
                     std::cout << oss.str() << std::endl;
                 }
-                }
-            }
                 if (all.empty()) {
+                    feed.reset();
+                } else {
+                    messages.reserve(all.size());
+                    for (const auto* str : all) {
+                        if (!str || str->empty()) {
+                            std::cout << "警告:未知原因:" << feed->key << "内有空的消息体" << std::endl;
+                            continue;
+                        }
+                        messages.emplace_back(*str);
+                    }
+                }
+            }
+            if (messages.empty()) {
                 co_await data_feed_thread_wait_event_coro();
                 continue;
             }
-            const auto n = all.size();
+            auto feed = feed_ref.lock();
-            for (size_t i = 0; i < n; ++i) {
+            if (!feed || !feed->enable || !feed->registered()) {
-                const auto* str = all[i];
+                break;
-                if (!str || str->empty()) {
-                    std::cout << "警告:未知原因:"
-                        << feed->key
-                        << "内有空的消息体"
-                        << std::endl;
-                    continue;
             }
-                std::string msg = *str;
+            for (auto& msg : messages) {
                 co_await feed->send_coro(msg);
             }
+            feed.reset();
             co_await data_feed_thread_yield_coro();
         }
         co_return;
     }
-    using Data_Source_Task_Map = std::map<Data_Source*, ucoro::awaitable<void>>;
+    void handle_loop_exception(std::exception_ptr exception) {
-    using Data_Feed_Task_Map = std::map<Data_Feed*, ucoro::awaitable<void>>;
+        if (!exception) {
-    void cleanup_data_source_loop_tasks(Data_Source_Task_Map& tasks) {
+            data_feed_thread_scheduler().set_exception(exception);
-        for (auto it = tasks.begin(); it != tasks.end();) {
-            if (!it->second.valid()) {
-                it = tasks.erase(it);
         }
-            else {
+        try {
-                ++it;
+            std::rethrow_exception(exception);
+        }
+        catch (const psco::operation_cancelled&) {
+
+        }
+        catch (...) {
+            data_feed_thread_scheduler().set_exception(exception);
         }
     }
-    }
+    void sync_data_source_loop_tasks(std::atomic<bool>& running) {
-    void cleanup_data_feed_loop_tasks(Data_Feed_Task_Map& tasks) {
-        for (auto it = tasks.begin(); it != tasks.end();) {
-            if (!it->second.valid()) {
-                it = tasks.erase(it);
-            }
-            else {
-                ++it;
-            }
-        }
-    }
-    void sync_data_source_loop_tasks(
-        std::atomic<bool>& running,
-        Data_Source_Task_Map& tasks
-    ) {
-        cleanup_data_source_loop_tasks(tasks);
         auto sources = Global::instance()->mode_acs.data_source_config.map.list();
         for (auto& source : sources) {
             if (!source || !source->enable) {
                 continue;
             }
-            if (tasks.find(source.get()) != tasks.end()) {
+            if (source->loop_task && source->loop_task->valid()) {
                 continue;
             }
             if (!source->is_open() && !source->open()) {
                 continue;
             }
-            auto task = data_source_loop_coro(running, source).detach_with_callback(
+            source->loop_task = std::make_unique<psco::awaitable<void>>(psco::with_callback(data_source_loop_coro(running, std::weak_ptr<Data_Source>(source)), [](std::exception_ptr exception) mutable {
-                [source](std::exception_ptr exception) mutable {
+                handle_loop_exception(exception);
-                    if (!is_ucoro_operation_cancelled(exception)) {
+            }));
-                        data_feed_thread_scheduler().set_exception(exception);
+            source->loop_task->start();
         }
     }
-            );
+    void sync_data_feed_loop_tasks(std::atomic<bool>& running) {
-            task.start();
-            if (task.valid()) {
-                tasks.emplace(source.get(), std::move(task));
-            }
-        }
-    }
-    void sync_data_feed_loop_tasks(
-        std::atomic<bool>& running,
-        Data_Feed_Task_Map& tasks
-    ) {
-        cleanup_data_feed_loop_tasks(tasks);
         auto feeds = Global::instance()->mode_acs.data_feed_config.map.list();
         for (auto& feed : feeds) {
             if (!feed || !feed->enable) {
                 continue;
             }
-            if (tasks.find(feed.get()) != tasks.end()) {
+            if (feed->loop_task && feed->loop_task->valid()) {
                 continue;
             }
             auto ret = feed->check_and_open();
             if (!ret) {
                 continue;
             }
-            auto task = data_feed_loop_coro(running, feed).detach_with_callback(
+            feed->loop_task = std::make_unique<psco::awaitable<void>>(psco::with_callback(data_feed_loop_coro(running, std::weak_ptr<Data_Feed>(feed)), [](std::exception_ptr exception) mutable {
-                [feed](std::exception_ptr exception) mutable {
+                handle_loop_exception(exception);
-                    if (!is_ucoro_operation_cancelled(exception)) {
+            }));
-                        data_feed_thread_scheduler().set_exception(exception);
+            feed->loop_task->start();
         }
     }
-            );
+    bool has_running_loop_tasks() {
-            task.start();
+        auto sources = Global::instance()->mode_acs.data_source_config.map.list();
-            if (task.valid()) {
+        for (auto& source : sources) {
-                tasks.emplace(feed.get(), std::move(task));
+            if (source && source->loop_task && source->loop_task->valid()) {
+                return true;
+            }
+        }
+        auto feeds = Global::instance()->mode_acs.data_feed_config.map.list();
+        for (auto& feed : feeds) {
+            if (feed && feed->loop_task && feed->loop_task->valid()) {
+                return true;
+            }
+        }
+        return false;
+    }
+    void cancel_loop_tasks() {
+        auto sources = Global::instance()->mode_acs.data_source_config.map.list();
+        for (auto& source : sources) {
+            if (source && source->loop_task && source->loop_task->valid()) {
+                source->loop_task->cancel();
+            }
+        }
+        auto feeds = Global::instance()->mode_acs.data_feed_config.map.list();
+        for (auto& feed : feeds) {
+            if (feed && feed->loop_task && feed->loop_task->valid()) {
+                feed->loop_task->cancel();
             }
         }
     }
-    void stop_all_data_source_loop_tasks(Data_Source_Task_Map& tasks) {
+    void stop_loop_tasks() {
         auto& scheduler = data_feed_thread_scheduler();
         scheduler.wake();
-        scheduler.cleanup_abandoned_tasks();
         auto start = std::chrono::steady_clock::now();
-        while (!tasks.empty()) {
+        while (has_running_loop_tasks()) {
             scheduler.rethrow_if_exception();
             scheduler.drain();
-            cleanup_data_source_loop_tasks(tasks);
+            if (!has_running_loop_tasks()) {
-            scheduler.cleanup_abandoned_tasks();
-            if (tasks.empty()) {
                 break;
             }
             if (std::chrono::steady_clock::now() - start > std::chrono::seconds(10)) {
-                std::cerr << "data_source_loop_coro stop timeout, abandon remaining tasks"
+                std::cerr << "data loop task stop timeout, cancel remaining tasks" << std::endl;
-                    << std::endl;
+                cancel_loop_tasks();
-                scheduler.abandon_remaining_tasks(tasks);
                 break;
             }
             scheduler.wait_for_callback_for(std::chrono::milliseconds(1));
         }
-        scheduler.cleanup_abandoned_tasks();
     }
-    void stop_all_data_feed_loop_tasks(Data_Feed_Task_Map& tasks) {
-        auto& scheduler = data_feed_thread_scheduler();
-        scheduler.wake();
-        scheduler.cleanup_abandoned_tasks();
-        auto start = std::chrono::steady_clock::now();
-        while (!tasks.empty()) {
-            scheduler.rethrow_if_exception();
-            scheduler.drain();
-            cleanup_data_feed_loop_tasks(tasks);
-            scheduler.cleanup_abandoned_tasks();
-            if (tasks.empty()) {
-                break;
 }
-            if (std::chrono::steady_clock::now() - start > std::chrono::seconds(10)) {
-                std::cerr << "data_feed_loop_coro stop timeout, abandon remaining tasks"
-                    << std::endl;
-                scheduler.abandon_remaining_tasks(tasks);
-                break;
-            }
-            scheduler.wait_for_callback_for(std::chrono::milliseconds(1));
-        }
-        scheduler.cleanup_abandoned_tasks();
-    }
-} // namespace
 void wake_data_feed_thread() {
     data_feed_thread_scheduler().wake();
 }
 void stop_data_feed_thread_scheduler() {
     data_feed_thread_scheduler().stop();
 }
-ucoro::awaitable<void> data_feed_thread_coro(std::atomic<bool>& running) {
+psco::awaitable<void> data_feed_thread_coro(std::atomic<bool>& running) {
     data_feed_thread_scheduler().reset();
     auto g = Global::instance();
     for (auto& feed : g->mode_acs.data_feed_config.map.list()) {
         if (feed->enable) {
             auto ret = feed->check_and_open();
             if (!ret) {
-                std::cout << "[Data_feed_Config]  ["
+                std::cout << "[Data_feed_Config]  [" << feed->key << "] 第一次打开失败！ 程序继续运行，等待后续重试。" << std::endl;
-                    << feed->key
-                    << "] 第一次打开失败！ 程序继续运行，等待后续重试。"
-                    << std::endl;
             }
         }
     }
-    Data_Source_Task_Map data_source_tasks;
-    Data_Feed_Task_Map data_feed_tasks;
     while (running.load(std::memory_order_acquire)) {
         auto& scheduler = data_feed_thread_scheduler();
         scheduler.rethrow_if_exception();
-        scheduler.cleanup_abandoned_tasks();
+        sync_data_source_loop_tasks(running);
-        sync_data_source_loop_tasks(running, data_source_tasks);
+        sync_data_feed_loop_tasks(running);
-        sync_data_feed_loop_tasks(running, data_feed_tasks);
         const auto resumed = scheduler.drain();
-        cleanup_data_source_loop_tasks(data_source_tasks);
-        cleanup_data_feed_loop_tasks(data_feed_tasks);
-        scheduler.cleanup_abandoned_tasks();
         if (resumed == 0) {
             scheduler.wait_for_work([&running] {
                 return !running.load(std::memory_order_acquire);
@@ -294,18 +239,15 @@ ucoro::awaitable<void> data_feed_thread_coro(std::atomic<bool>& running) {
         }
     }
     data_feed_thread_scheduler().stop();
-    stop_all_data_source_loop_tasks(data_source_tasks);
+    stop_loop_tasks();
-    stop_all_data_feed_loop_tasks(data_feed_tasks);
     co_return;
 }
 void io_coro(std::atomic<bool>& running) {
     try {
-        ucoro::sync_await(data_feed_thread_coro(running));
+        psco::sync_await(data_feed_thread_coro(running));
     }
     catch (const std::exception& e) {
-        std::cerr << "data_feed_thread_coro exception: "
+        std::cerr << "data_feed_thread_coro exception: " << e.what() << std::endl;
-            << e.what()
-            << std::endl;
         Psc::fail_fast_core_dump("");
     }
     catch (...) {