fix: fix deadlock in some cases caused by loadEngineSnapshot()

Author: ShrBox

src/legacy/api/EventAPI.cpp

@@ -908,14 +908,12 @@ void InitBasicEventListeners() {
             }
 #ifndef LSE_BACKEND_NODEJS
             try {
-                auto snapshot = globalShareData->globalEngineSnapshot.load(std::memory_order_acquire);
-                if (snapshot) {
-                    for (auto& engine : *snapshot) {
-                        if (EngineManager::isValid(engine.get())
-                            && EngineManager::getEngineType(engine) == LLSE_BACKEND_TYPE) {
-                            EngineScope enter(engine.get());
-                            engine->messageQueue()->loopQueue(script::utils::MessageQueue::LoopType::kLoopOnce);
-                        }
+                auto snapshot = EngineManager::getGlobalEngines();
+                for (auto& engine : snapshot) {
+                    if (EngineManager::isValid(engine.get())
+                        && EngineManager::getEngineType(engine) == LLSE_BACKEND_TYPE) {
+                        EngineScope enter(engine.get());
+                        engine->messageQueue()->loopQueue(script::utils::MessageQueue::LoopType::kLoopOnce);
                     }
                 }
             } catch (...) {

src/legacy/engine/EngineManager.cpp

@@ -7,8 +7,8 @@
 #include "legacy/main/NodeJsHelper.h"
 #endif
 
-#include <atomic>
 #include <mutex>
+#include <shared_mutex>
 
 using namespace script;
 
@@ -19,19 +19,22 @@ void refreshEngineSnapshotLocked() {
         globalShareData->globalEngineList.begin(),
         globalShareData->globalEngineList.end()
     );
-    globalShareData->globalEngineSnapshot.store(snapshot, std::memory_order_release);
+
+    std::unique_lock snapshotLock(globalShareData->engineSnapshotLock);
+    globalShareData->globalEngineSnapshot = std::move(snapshot);
 }
 
 std::shared_ptr<std::vector<std::shared_ptr<ScriptEngine>>> loadEngineSnapshot() {
-    return globalShareData->globalEngineSnapshot.load(std::memory_order_acquire);
+    std::shared_lock snapshotLock(globalShareData->engineSnapshotLock);
+    return globalShareData->globalEngineSnapshot;
 }
 
 } // namespace
 
 ///////////////////////////////// API /////////////////////////////////
 
 bool EngineManager::unregisterEngine(std::shared_ptr<ScriptEngine> const& toDelete) {
-    std::unique_lock lock(globalShareData->engineListLock);
+    std::lock_guard lock(globalShareData->engineListLock);
     for (auto engine = globalShareData->globalEngineList.begin(); engine != globalShareData->globalEngineList.end();
          ++engine) {
         if (*engine == toDelete) {
@@ -44,7 +47,7 @@ bool EngineManager::unregisterEngine(std::shared_ptr<ScriptEngine> const& toDele
 }
 
 bool EngineManager::registerEngine(std::shared_ptr<ScriptEngine> const& engine) {
-    std::unique_lock lock(globalShareData->engineListLock);
+    std::lock_guard lock(globalShareData->engineListLock);
     globalShareData->globalEngineList.push_back(engine);
     refreshEngineSnapshotLocked();
     return true;

src/legacy/engine/GlobalShareData.cpp

@@ -4,7 +4,7 @@
 #include "legacy/engine/LocalShareData.h"
 
 #include <Windows.h>
-#include <atomic>
+#include <mutex>
 #include <string>
 #include <vector>
 
@@ -43,11 +43,11 @@ void InitGlobalShareData() {
         globalShareData                 = static_cast<GlobalDataType*>(address);
     }
 
-    globalShareData->globalEngineSnapshot.store(
-        std::make_shared<std::vector<std::shared_ptr<ScriptEngine>>>(
+    {
+        std::unique_lock snapshotLock(globalShareData->engineSnapshotLock);
+        globalShareData->globalEngineSnapshot = std::make_shared<std::vector<std::shared_ptr<ScriptEngine>>>(
             globalShareData->globalEngineList.begin(),
             globalShareData->globalEngineList.end()
-        ),
-        std::memory_order_release
-    );
+        );
+    }
 }

src/legacy/engine/GlobalShareData.h

@@ -2,8 +2,9 @@
 #include "legacy/api/APIHelp.h"
 
 #include <Windows.h>
-#include <atomic>
 #include <map>
+#include <memory>
+#include <mutex>
 #include <shared_mutex>
 #include <string>
 #include <vector>
@@ -27,9 +28,10 @@ struct MessageHandlers {
 // 全局共享数据
 struct GlobalDataType {
     // 引擎管理器表
-    std::shared_mutex                                                        engineListLock;
+    std::mutex                                                               engineListLock;
     std::vector<std::shared_ptr<ScriptEngine>>                               globalEngineList;
-    std::atomic<std::shared_ptr<std::vector<std::shared_ptr<ScriptEngine>>>> globalEngineSnapshot;
+    std::shared_mutex                                                         engineSnapshotLock;
+    std::shared_ptr<std::vector<std::shared_ptr<ScriptEngine>>>              globalEngineSnapshot;
 
     // 导出函数表
     std::unordered_map<std::string, ExportedFuncData> exportedFuncs;

src/legacy/engine/MessageSystem.cpp

@@ -322,10 +322,8 @@ bool ModuleMessageResult::cancel() const {
 void MessageSystemLoopOnce() {
     // if (!messageLoopLock.try_lock())
     //     return;
-    auto snapshot = globalShareData->globalEngineSnapshot.load(std::memory_order_acquire);
-    if (!snapshot) return;
-
-    for (auto& engine : *snapshot) {
+    auto snapshot = EngineManager::getGlobalEngines();
+    for (auto& engine : snapshot) {
         if (EngineManager::isValid(engine) && EngineManager::getEngineType(engine) == LLSE_BACKEND_TYPE) {
             try {
                 if (EngineScope::currentEngine() == engine.get())