fix(core): fix the problem of multi-threading at startup time

lvfen · Nov 28, 2022 · 3a8b739 · 3a8b739
1 parent c7aae48
commit 3a8b739
Show file tree

Hide file tree

Showing 4 changed files with 28 additions and 18 deletions.
diff --git a/android/sdk/src/main/jni/src/bridge/entry.cc b/android/sdk/src/main/jni/src/bridge/entry.cc
@@ -570,7 +570,7 @@ jlong InitInstance(JNIEnv* j_env,
       v8::Isolate* isolate = v8_vm->isolate_;
       isolate->SetData(kRuntimeSlotIndex, reinterpret_cast<void*>(runtime_id));
     } else {
-      engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
+      engine = std::make_shared<Engine>();
       reuse_engine_map[group] = std::make_pair(engine, 1);
       runtime->SetEngine(engine);
     }
@@ -586,20 +586,20 @@ jlong InitInstance(JNIEnv* j_env,
                           << ", use_count = " << engine.use_count();
     } else {
       TDF_BASE_DLOG(INFO) << "engine create";
-      engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
+      engine = std::make_shared<Engine>();
       runtime->SetEngine(engine);
       reuse_engine_map[group] = std::make_pair(engine, 1);
     }
   } else {  // kDefaultEngineId
     TDF_BASE_DLOG(INFO) << "default create engine";
-    engine = std::make_shared<Engine>(std::move(engine_cb_map), param);
+    engine = std::make_shared<Engine>();
     runtime->SetEngine(engine);
   }
+  engine->AsyncInit(param, std::move(engine_cb_map));
   runtime->SetScope(engine->CreateScope("", std::move(scope_cb_map)));
   TDF_BASE_DLOG(INFO) << "group = " << group;
   runtime->SetGroupId(group);
   TDF_BASE_LOG(INFO) << "InitInstance end, runtime_id = " << runtime_id;
-
   return runtime_id;
 }
 

diff --git a/core/include/core/engine.h b/core/include/core/engine.h
@@ -38,18 +38,18 @@
 
 class Scope;
 
-class Engine {
+class Engine: public std::enable_shared_from_this<Engine> {
  public:
   using RegisterMap = hippy::base::RegisterMap;
   using VM = hippy::napi::VM;
   using VMInitParam = hippy::napi::VMInitParam;
   using RegisterFunction = hippy::base::RegisterFunction;
 
-  Engine(
-      std::unique_ptr<RegisterMap> map = std::make_unique<RegisterMap>(),
-      const std::shared_ptr<VMInitParam>& param = nullptr);
+  Engine();
   virtual ~Engine();
 
+  void AsyncInit(const std::shared_ptr<VMInitParam>& param = nullptr,
+                 std::unique_ptr<RegisterMap> map = std::make_unique<RegisterMap>());
   void Enter();
   void Exit();
   std::shared_ptr<Scope> CreateScope(

diff --git a/core/src/engine.cc b/core/src/engine.cc
@@ -27,14 +27,7 @@
 
 constexpr uint32_t Engine::kDefaultWorkerPoolSize = 1;
 
-Engine::Engine(std::unique_ptr<RegisterMap> map, const std::shared_ptr<VMInitParam>& init_param)
-    : vm_(nullptr), map_(std::move(map)), scope_cnt_(0) {
-  SetupThreads();
-
-  std::shared_ptr<JavaScriptTask> task = std::make_shared<JavaScriptTask>();
-  task->callback = [=] { CreateVM(init_param); };
-  js_runner_->PostTask(task);
-}
+Engine::Engine() : vm_(nullptr), scope_cnt_(0) {}
 
 Engine::~Engine() {
   TDF_BASE_DLOG(INFO) << "~Engine";
@@ -78,8 +71,7 @@ void Engine::SetupThreads() {
 void Engine::CreateVM(const std::shared_ptr<VMInitParam>& param) {
   TDF_BASE_DLOG(INFO) << "Engine CreateVM";
   vm_ = hippy::napi::CreateVM(param);
-
-  RegisterMap::const_iterator it = map_->find(hippy::base::kVMCreateCBKey);
+  auto it = map_->find(hippy::base::kVMCreateCBKey);
   if (it != map_->end()) {
     RegisterFunction f = it->second;
     if (f) {
@@ -91,6 +83,23 @@ void Engine::CreateVM(const std::shared_ptr<VMInitParam>& param) {
   }
 }
 
+void Engine::AsyncInit(const std::shared_ptr<VMInitParam>& param, std::unique_ptr<RegisterMap> map) {
+  SetupThreads();
+
+  map_ = std::move(map);
+  auto weak_engine = weak_from_this();
+  auto task = std::make_shared<JavaScriptTask>();
+  task->callback = [weak_engine, param] {
+    auto engine = weak_engine.lock();
+    TDF_BASE_DCHECK(engine);
+    if (!engine) {
+      return;
+    }
+    engine->CreateVM(param);
+  };
+  js_runner_->PostTask(task);
+}
+
 void Engine::Enter() {
   TDF_BASE_DLOG(INFO) << "Engine Enter";
   std::lock_guard<std::mutex> lock(cnt_mutex_);

diff --git a/ios/sdk/base/HippyJSEnginesMapper.mm b/ios/sdk/base/HippyJSEnginesMapper.mm
@@ -55,6 +55,7 @@ + (instancetype)defaultInstance {
         return ref.first;
     } else {
         std::shared_ptr<Engine> engine = std::make_shared<Engine>();
+        engine->AsyncInit();
         [self setEngine:engine forKey:key];
         return engine;
     }