diff --git a/frameworks/napi/include/events_emitter.h b/frameworks/napi/include/events_emitter.h
index 65fd06aa1e91404a18cb73d46cdcd77680645c0c..765a4db87aa1123fdbc2afbc56440f75906828ed 100644
--- a/frameworks/napi/include/events_emitter.h
+++ b/frameworks/napi/include/events_emitter.h
@@ -66,8 +66,6 @@ struct AsyncCallbackInfo {
 };
 
 using EventData = std::map<std::string, Val>;
-using CallbackInfos = std::vector<AsyncCallbackInfo *>;
-
 struct EventDataWorker {
     EventData data;
     AsyncCallbackInfo* callbackInfo;
diff --git a/frameworks/napi/src/events_emitter.cpp b/frameworks/napi/src/events_emitter.cpp
index b590895e30ab58639d8d2bd23dc89e083f1cce9a..f94d2b4e270c58e98763e22cf518c47e4001f48a 100644
--- a/frameworks/napi/src/events_emitter.cpp
+++ b/frameworks/napi/src/events_emitter.cpp
@@ -31,7 +31,8 @@ DEFINE_HILOG_LABEL("events_emitter");
 using namespace std;
 namespace OHOS {
 namespace AppExecFwk {
-    static map<uint32_t, CallbackInfos> emitterInstances;
+    static std::mutex emitterInsMutex;
+    static map<uint32_t, std::vector<AsyncCallbackInfo *>> emitterInstances;
     std::shared_ptr<EventHandlerInstance> eventHandler;
     EventHandlerInstance::EventHandlerInstance(const std::shared_ptr<EventRunner>& runner): EventHandler(runner)
     {
@@ -92,6 +93,7 @@ namespace AppExecFwk {
         HILOGI("Prepare to process callbackInner %{public}p", callbackInner);
         if (callbackInner->isDeleted) {
             HILOGI("ProcessEvent isDeleted callbackInfo = %{public}p", callbackInner);
+            std::lock_guard<std::mutex> lock(emitterInsMutex);
             if (callbackInner->callback != nullptr) {
                 napi_delete_reference(callbackInner->env, callbackInner->callback);
             }
@@ -106,6 +108,7 @@ namespace AppExecFwk {
             napi_call_function(callbackInner->env, nullptr, callback, 1, &resultData, &returnVal);
             if (callbackInner->once) {
                 HILOGI("ProcessEvent delete once callback callbackInfo = %{public}p", callbackInner);
+                std::lock_guard<std::mutex> lock(emitterInsMutex);
                 callbackInner->isDeleted = true;
                 napi_delete_reference(callbackInner->env, callbackInner->callback);
                 callbackInner->callback = nullptr;
@@ -117,13 +120,14 @@ namespace AppExecFwk {
     {
         uint32_t eventId = event->GetInnerEventId();
         HILOGI("ProcessEvent, eventId = %{public}d", eventId);
+        std::lock_guard<std::mutex> lock(emitterInsMutex);
         auto subscribe = emitterInstances.find(eventId);
         if (subscribe == emitterInstances.end()) {
             HILOGW("ProcessEvent has no callback");
             return;
         }
 
-        CallbackInfos& callbackInfos = subscribe->second;
+        auto& callbackInfos = subscribe->second;
         HILOGI("ProcessEvent, size = %{public}zu", callbackInfos.size());
         EventData eventData = *(event->GetUniqueObject<EventData>());
         for (auto iter = callbackInfos.begin(); iter != callbackInfos.end();) {
@@ -237,7 +241,7 @@ namespace AppExecFwk {
         uint32_t eventIdValue;
         napi_get_value_uint32(env, eventId, &eventIdValue);
         HILOGI("OnOrOnce eventIdValue:%{public}d", eventIdValue);
-
+        std::lock_guard<std::mutex> lock(emitterInsMutex);
         if (!IsExistSameCallback(env, eventIdValue, argv[1], once)) {
             AsyncCallbackInfo* callbackInfo = new (std::nothrow) AsyncCallbackInfo();
             if (!callbackInfo) {
@@ -256,8 +260,13 @@ namespace AppExecFwk {
     napi_value JS_On(napi_env env, napi_callback_info cbinfo)
     {
         HILOGI("JS_On start");
-        OnOrOnce(env, cbinfo, false);
-        return nullptr;
+        return OnOrOnce(env, cbinfo, false);
+    }
+
+    napi_value JS_Once(napi_env env, napi_callback_info cbinfo)
+    {
+        HILOGI("JS_Once start");
+        return OnOrOnce(env, cbinfo, true);
     }
 
     napi_value JS_Off(napi_env env, napi_callback_info cbinfo)
@@ -274,6 +283,7 @@ namespace AppExecFwk {
 
         uint32_t eventId;
         napi_get_value_uint32(env, argv[0], &eventId);
+        std::lock_guard<std::mutex> lock(emitterInsMutex);
         auto subscribe = emitterInstances.find(eventId);
         if (subscribe != emitterInstances.end()) {
             for (auto callbackInfo : subscribe->second) {
@@ -284,13 +294,6 @@ namespace AppExecFwk {
         return nullptr;
     }
 
-    napi_value JS_Once(napi_env env, napi_callback_info cbinfo)
-    {
-        HILOGI("JS_Once start");
-        OnOrOnce(env, cbinfo, true);
-        return nullptr;
-    }
-
     bool ParseEventData(napi_env env, napi_value key, napi_value data, Val* &val, char keyChars[NAPI_VALUE_STRING_LEN])
     {
         napi_valuetype valueType;
@@ -384,6 +387,7 @@ namespace AppExecFwk {
 
     bool IsExistValidCallback(napi_env env, uint32_t eventId)
     {
+        std::lock_guard<std::mutex> lock(emitterInsMutex);
         auto subscribe = emitterInstances.find(eventId);
         if (subscribe == emitterInstances.end()) {
             HILOGW("JS_Emit has no callback");