From 15443fba1ced9eb0b89f07e0296a75221ddede87 Mon Sep 17 00:00:00 2001 From: l00635678 Date: Sat, 4 Jan 2025 16:30:19 +0800 Subject: [PATCH] =?UTF-8?q?=E3=80=90=E6=95=B0=E6=8D=AE=E4=B8=9A=E5=8A=A1-?= =?UTF-8?q?=E7=BD=91=E7=BB=9C=E7=AE=A1=E7=90=86-=E4=BD=8E=E6=A6=82?= =?UTF-8?q?=E7=8E=87=E3=80=91=E4=BD=BF=E7=94=A8=E9=92=89=E9=92=89=E4=BD=8E?= =?UTF-8?q?=E6=A6=82=E7=8E=87=E5=87=BA=E7=8E=B0=E7=BD=91=E7=BB=9C=E7=AE=A1?= =?UTF-8?q?=E7=90=86=E5=8D=A1=E6=AD=BB?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: k-lee9575 --- .../connection/include/net_connection_impl.h | 2 +- .../src/net_connection_callback.cpp | 72 +++++++++---------- .../cj/connection/src/net_connection_impl.cpp | 8 +-- .../src/net_conn_callback_observer.cpp | 72 +++++++++---------- .../options/include/netconnection.h | 2 +- .../connection/options/src/netconnection.cpp | 8 +-- utils/napi_utils/include/event_manager.h | 5 +- utils/napi_utils/src/event_manager.cpp | 18 +++-- 8 files changed, 92 insertions(+), 95 deletions(-) diff --git a/frameworks/cj/connection/include/net_connection_impl.h b/frameworks/cj/connection/include/net_connection_impl.h index ab8d520a6..accd3b609 100644 --- a/frameworks/cj/connection/include/net_connection_impl.h +++ b/frameworks/cj/connection/include/net_connection_impl.h @@ -91,7 +91,7 @@ private: extern std::map NET_CONNECTIONS; -extern std::mutex g_netConnectionsMutex; +extern std::shared_mutex g_netConnectionsMutex; } // namespace OHOS::NetManagerStandard #endif \ No newline at end of file diff --git a/frameworks/cj/connection/src/net_connection_callback.cpp b/frameworks/cj/connection/src/net_connection_callback.cpp index a6faa882b..55d6fd64b 100644 --- a/frameworks/cj/connection/src/net_connection_callback.cpp +++ b/frameworks/cj/connection/src/net_connection_callback.cpp @@ -24,20 +24,20 @@ int32_t ConnectionCallbackObserver::NetAvailable(sptr &netHandle) if (netHandle == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netAvailible.size() == 0) { + if (netConnection->second->netAvailible.size() == 0) { NETMANAGER_BASE_LOGE("no NetAvailable func registered"); return 0; } int32_t id = netHandle->GetNetId(); - int len = static_cast(netConnection->netAvailible.size()); + int len = static_cast(netConnection->second->netAvailible.size()); for (int i = 0; i < len; i++) { - netConnection->netAvailible[i](id); + netConnection->second->netAvailible[i](id); } return 0; } @@ -79,20 +79,20 @@ int32_t ConnectionCallbackObserver::NetCapabilitiesChange(sptr &netHa NETMANAGER_BASE_LOGE("NetCapabilitiesChange param is nullptr"); return 0; } - std::lock_guard lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netCapabilitiesChange.size() == 0) { + if (netConnection->second->netCapabilitiesChange.size() == 0) { NETMANAGER_BASE_LOGE("no NetCapabilitiesChange func registered"); return 0; } int32_t id = netHandle->GetNetId(); - int len = static_cast(netConnection->netCapabilitiesChange.size()); + int len = static_cast(netConnection->second->netCapabilitiesChange.size()); for (int i = 0; i < len; i++) { auto bearTypes = netAllCap->bearerTypes_; auto netCaps = netAllCap->netCaps_; @@ -108,7 +108,7 @@ int32_t ConnectionCallbackObserver::NetCapabilitiesChange(sptr &netHa } CNetCapabilityInfo info = {.netHandle = id, .netCap = capabilities}; - netConnection->netCapabilitiesChange[i](info); + netConnection->second->netCapabilitiesChange[i](info); } return 0; } @@ -170,18 +170,18 @@ int32_t ConnectionCallbackObserver::NetConnectionPropertiesChange(sptr lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netConnectionPropertiesChange.size() == 0) { + if (netConnection->second->netConnectionPropertiesChange.size() == 0) { return 0; } int32_t id = netHandle->GetNetId(); - int len = static_cast(netConnection->netConnectionPropertiesChange.size()); + int len = static_cast(netConnection->second->netConnectionPropertiesChange.size()); for (int i = 0; i < len; i++) { CConnectionProperties props = {.interfaceName = MallocCString(info->ifaceName_), .domains = MallocCString(info->domain_), @@ -193,7 +193,7 @@ int32_t ConnectionCallbackObserver::NetConnectionPropertiesChange(sptrnetConnectionPropertiesChange[i](id, props); + netConnection->second->netConnectionPropertiesChange[i](id, props); } return 0; } @@ -203,59 +203,59 @@ int32_t ConnectionCallbackObserver::NetLost(sptr &netHandle) if (netHandle == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netLost.size() == 0) { + if (netConnection->second->netLost.size() == 0) { NETMANAGER_BASE_LOGE("no NetLost func registered"); return 0; } int32_t id = netHandle->GetNetId(); - int32_t len = static_cast(netConnection->netLost.size()); + int32_t len = static_cast(netConnection->second->netLost.size()); for (int32_t i = 0; i < len; i++) { - netConnection->netLost[i](id); + netConnection->second->netLost[i](id); } return 0; } int32_t ConnectionCallbackObserver::NetUnavailable() { - std::lock_guard lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netUnavailable.size() == 0) { + if (netConnection->second->netUnavailable.size() == 0) { NETMANAGER_BASE_LOGE("no NetUnavailable func registered"); return 0; } - int len = static_cast(netConnection->netUnavailable.size()); + int len = static_cast(netConnection->second->netUnavailable.size()); for (int i = 0; i < len; i++) { - netConnection->netUnavailable[i](); + netConnection->second->netUnavailable[i](); } return 0; } int32_t ConnectionCallbackObserver::NetBlockStatusChange(sptr &netHandle, bool blocked) { - std::lock_guard lock(g_netConnectionsMutex); - NetConnectionImpl *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end() || netConnection->second == nullptr) { NETMANAGER_BASE_LOGE("can not find netConnection handle"); return 0; } - if (netConnection->netBlockStatusChange.size() == 0) { + if (netConnection->second->netBlockStatusChange.size() == 0) { NETMANAGER_BASE_LOGE("no NetBlockStatusChange func registered"); return 0; } int32_t id = netHandle->GetNetId(); - int len = static_cast(netConnection->netBlockStatusChange.size()); + int len = static_cast(netConnection->second->netBlockStatusChange.size()); for (int i = 0; i < len; i++) { - netConnection->netBlockStatusChange[i](id, blocked); + netConnection->second->netBlockStatusChange[i](id, blocked); } return 0; } diff --git a/frameworks/cj/connection/src/net_connection_impl.cpp b/frameworks/cj/connection/src/net_connection_impl.cpp index ffc6f0928..10694e392 100644 --- a/frameworks/cj/connection/src/net_connection_impl.cpp +++ b/frameworks/cj/connection/src/net_connection_impl.cpp @@ -14,14 +14,14 @@ */ #include "net_connection_impl.h" #include "cj_lambda.h" -#include "mutex" +#include #include "net_conn_client.h" #include "netmanager_base_log.h" #include "net_specifier.h" namespace OHOS::NetManagerStandard { std::map NET_CONNECTIONS; -std::mutex g_netConnectionsMutex; +std::shared_mutex g_netConnectionsMutex; NetConnectionProxy::NetConnectionProxy(CNetSpecifier specifier, uint32_t timeout) { @@ -118,7 +118,7 @@ NetConnectionImpl::NetConnectionImpl() NetConnectionImpl *NetConnectionImpl::MakeNetConnection() { - std::lock_guard lock(g_netConnectionsMutex); + std::unique_lock lock(g_netConnectionsMutex); auto netConnection = new NetConnectionImpl(); if (netConnection) { NET_CONNECTIONS[netConnection->observer_.GetRefPtr()] = netConnection; @@ -128,7 +128,7 @@ NetConnectionImpl *NetConnectionImpl::MakeNetConnection() void NetConnectionImpl::DeleteNetConnection(NetConnectionImpl *netConnection) { - std::lock_guard lock(g_netConnectionsMutex); + std::unique_lock lock(g_netConnectionsMutex); NET_CONNECTIONS.erase(netConnection->observer_.GetRefPtr()); delete netConnection; } diff --git a/frameworks/js/napi/connection/observer/src/net_conn_callback_observer.cpp b/frameworks/js/napi/connection/observer/src/net_conn_callback_observer.cpp index 4262ef6a2..05090d286 100644 --- a/frameworks/js/napi/connection/observer/src/net_conn_callback_observer.cpp +++ b/frameworks/js/napi/connection/observer/src/net_conn_callback_observer.cpp @@ -26,17 +26,17 @@ int32_t NetConnCallbackObserver::NetAvailable(sptr &netHandle) if (netHandle == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -51,7 +51,7 @@ int32_t NetConnCallbackObserver::NetAvailable(sptr &netHandle) std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_AVAILABLE, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_AVAILABLE, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_AVAILABLE, handler, netConnection->second->moduleId_); return 0; } @@ -61,17 +61,17 @@ int32_t NetConnCallbackObserver::NetCapabilitiesChange(sptr &netHandl if (netHandle == nullptr || netAllCap == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -87,7 +87,7 @@ int32_t NetConnCallbackObserver::NetCapabilitiesChange(sptr &netHandl std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_CAPABILITIES_CHANGE, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_CAPABILITIES_CHANGE, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_CAPABILITIES_CHANGE, handler, netConnection->second->moduleId_); return 0; } @@ -97,17 +97,17 @@ int32_t NetConnCallbackObserver::NetConnectionPropertiesChange(sptr & if (netHandle == nullptr || info == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -123,7 +123,7 @@ int32_t NetConnCallbackObserver::NetConnectionPropertiesChange(sptr & std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_CONNECTION_PROPERTIES_CHANGE, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_CONNECTION_PROPERTIES_CHANGE, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_CONNECTION_PROPERTIES_CHANGE, handler, netConnection->second->moduleId_); return 0; } @@ -132,17 +132,17 @@ int32_t NetConnCallbackObserver::NetLost(sptr &netHandle) if (netHandle == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -156,23 +156,23 @@ int32_t NetConnCallbackObserver::NetLost(sptr &netHandle) std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_LOST, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_LOST, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_LOST, handler, netConnection->second->moduleId_); return 0; } int32_t NetConnCallbackObserver::NetUnavailable() { - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -185,7 +185,7 @@ int32_t NetConnCallbackObserver::NetUnavailable() std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_UNAVAILABLE, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_UNAVAILABLE, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_UNAVAILABLE, handler, netConnection->second->moduleId_); return 0; } @@ -194,17 +194,17 @@ int32_t NetConnCallbackObserver::NetBlockStatusChange(sptr &netHandle if (netHandle == nullptr) { return 0; } - std::lock_guard lock(g_netConnectionsMutex); - if (NET_CONNECTIONS.find(this) == NET_CONNECTIONS.end()) { + std::shared_lock lock(g_netConnectionsMutex); + auto netConnection = NET_CONNECTIONS.find(this); + if (netConnection == NET_CONNECTIONS.end()) { NETMANAGER_BASE_LOGI("can not find netConnection key"); return 0; } - NetConnection *netConnection = NET_CONNECTIONS[this]; - if (netConnection == nullptr) { + if (netConnection->second == nullptr) { NETMANAGER_BASE_LOGI("can not find netConnection handle"); return 0; } - auto manager = netConnection->GetEventManager(); + auto manager = netConnection->second->GetEventManager(); if (manager == nullptr) { return 0; } @@ -218,7 +218,7 @@ int32_t NetConnCallbackObserver::NetBlockStatusChange(sptr &netHandle std::pair arg = {NapiUtils::GetUndefined(env), obj}; manager->Emit(EVENT_NET_BLOCK_STATUS_CHANGE, arg); }; - manager->EmitByUvWithModuleId(EVENT_NET_BLOCK_STATUS_CHANGE, handler, netConnection->moduleId_); + manager->EmitByUvWithModuleId(EVENT_NET_BLOCK_STATUS_CHANGE, handler, netConnection->second->moduleId_); return 0; } diff --git a/frameworks/js/napi/connection/options/include/netconnection.h b/frameworks/js/napi/connection/options/include/netconnection.h index 1a3eff355..dc1c13ec3 100644 --- a/frameworks/js/napi/connection/options/include/netconnection.h +++ b/frameworks/js/napi/connection/options/include/netconnection.h @@ -52,7 +52,7 @@ private: }; extern std::map NET_CONNECTIONS; -extern std::mutex g_netConnectionsMutex; +extern std::shared_mutex g_netConnectionsMutex; } // namespace OHOS::NetManagerStandard #endif /* NETMANAGER_BASE_NETCONNECTION_H */ diff --git a/frameworks/js/napi/connection/options/src/netconnection.cpp b/frameworks/js/napi/connection/options/src/netconnection.cpp index 3de5f4eee..03f09c371 100644 --- a/frameworks/js/napi/connection/options/src/netconnection.cpp +++ b/frameworks/js/napi/connection/options/src/netconnection.cpp @@ -16,11 +16,11 @@ #include "netconnection.h" #include "netmanager_base_log.h" -#include +#include namespace OHOS::NetManagerStandard { std::map NET_CONNECTIONS; -std::mutex g_netConnectionsMutex; +std::shared_mutex g_netConnectionsMutex; NetConnection::NetConnection(EventManager *eventManager) : hasNetSpecifier_(false), @@ -33,7 +33,7 @@ NetConnection::NetConnection(EventManager *eventManager) NetConnection *NetConnection::MakeNetConnection(EventManager *eventManager) { - std::lock_guard lock(g_netConnectionsMutex); + std::unique_lock lock(g_netConnectionsMutex); auto netConnection = new NetConnection(eventManager); NET_CONNECTIONS[netConnection->observer_.GetRefPtr()] = netConnection; return netConnection; @@ -41,7 +41,7 @@ NetConnection *NetConnection::MakeNetConnection(EventManager *eventManager) void NetConnection::DeleteNetConnection(NetConnection *netConnection) { - std::lock_guard lock(g_netConnectionsMutex); + std::unique_lock lock(g_netConnectionsMutex); NET_CONNECTIONS.erase(netConnection->observer_.GetRefPtr()); delete netConnection; } diff --git a/utils/napi_utils/include/event_manager.h b/utils/napi_utils/include/event_manager.h index db8e9f016..3444ede37 100644 --- a/utils/napi_utils/include/event_manager.h +++ b/utils/napi_utils/include/event_manager.h @@ -18,7 +18,7 @@ #include #include -#include +#include #include @@ -58,9 +58,8 @@ public: void SetRef(napi_ref ref); private: - std::mutex mutexForListenersAndEmitByUv_; + std::shared_mutex mutexForListenersAndEmitByUv_; std::mutex mutexForEmitAndEmitByUv_; - std::mutex mutex_; std::list listeners_; void *data_ = nullptr; std::atomic_bool isValid_; diff --git a/utils/napi_utils/src/event_manager.cpp b/utils/napi_utils/src/event_manager.cpp index 0d3924b56..636dc4376 100644 --- a/utils/napi_utils/src/event_manager.cpp +++ b/utils/napi_utils/src/event_manager.cpp @@ -40,7 +40,7 @@ bool EventManager::IsValid() const void EventManager::AddListener(napi_env env, const std::string &type, napi_value callback, bool once, bool asyncCallback) { - std::lock_guard lock(mutexForListenersAndEmitByUv_); + std::unique_lock lock(mutexForListenersAndEmitByUv_); auto it = std::remove_if(listeners_.begin(), listeners_.end(), [type](const EventListener &listener) -> bool { return listener.MatchType(type); }); if (it != listeners_.end()) { @@ -51,7 +51,7 @@ void EventManager::AddListener(napi_env env, const std::string &type, napi_value void EventManager::DeleteListener(const std::string &type, napi_value callback) { - std::lock_guard lock(mutexForListenersAndEmitByUv_); + std::unique_lock lock(mutexForListenersAndEmitByUv_); auto it = std::remove_if(listeners_.begin(), listeners_.end(), [type, callback](const EventListener &listener) -> bool { return listener.Match(type, callback); @@ -61,7 +61,7 @@ void EventManager::DeleteListener(const std::string &type, napi_value callback) void EventManager::Emit(const std::string &type, const std::pair &argv) { - std::lock_guard lock1(mutexForListenersAndEmitByUv_); + std::unique_lock lock1(mutexForListenersAndEmitByUv_); std::lock_guard lock2(mutexForEmitAndEmitByUv_); std::for_each(listeners_.begin(), listeners_.end(), [type, argv](const EventListener &listener) { if (listener.IsAsyncCallback()) { @@ -82,19 +82,17 @@ void EventManager::Emit(const std::string &type, const std::pair lock(mutex_); data_ = data; } void *EventManager::GetData() { - std::lock_guard lock(mutex_); return data_; } void EventManager::EmitByUvWithModuleId(const std::string &type, const NapiUtils::UvHandler &handler, uint64_t moduleId) { - std::lock_guard lock1(mutexForListenersAndEmitByUv_); + std::shared_lock lock1(mutexForListenersAndEmitByUv_); std::lock_guard lock2(mutexForEmitAndEmitByUv_); if (!IsValid()) { return; @@ -107,7 +105,7 @@ void EventManager::EmitByUvWithModuleId(const std::string &type, const NapiUtils void EventManager::EmitByUv(const std::string &type, void *data, void(handler)(uv_work_t *, int status)) { - std::lock_guard lock1(mutexForListenersAndEmitByUv_); + std::shared_lock lock1(mutexForListenersAndEmitByUv_); std::lock_guard lock2(mutexForEmitAndEmitByUv_); if (!IsValid()) { return; @@ -121,14 +119,14 @@ void EventManager::EmitByUv(const std::string &type, void *data, void(handler)(u bool EventManager::HasEventListener(const std::string &type) { - std::lock_guard lock2(mutexForListenersAndEmitByUv_); + std::shared_lock lock2(mutexForListenersAndEmitByUv_); return std::any_of(listeners_.begin(), listeners_.end(), [&type](const EventListener &listener) -> bool { return listener.MatchType(type); }); } void EventManager::DeleteListener(const std::string &type) { - std::lock_guard lock2(mutexForListenersAndEmitByUv_); + std::unique_lock lock2(mutexForListenersAndEmitByUv_); auto it = std::remove_if(listeners_.begin(), listeners_.end(), [type](const EventListener &listener) -> bool { return listener.MatchType(type); }); listeners_.erase(it, listeners_.end()); @@ -137,7 +135,7 @@ void EventManager::DeleteListener(const std::string &type) void EventManager::DeleteAllListener() { NETMANAGER_BASE_LOGI("DeleteAllListener"); - std::lock_guard lock(mutexForListenersAndEmitByUv_); + std::unique_lock lock(mutexForListenersAndEmitByUv_); listeners_.clear(); } -- Gitee