diff --git a/services/implementation/include/device_manager_service_impl.h b/services/implementation/include/device_manager_service_impl.h
index 9efda6ff9b6370b71ba5bf01aec3133ab07da5dc..cae4c87ff135a4d06517097c3b02d1d90bfd6469 100644
--- a/services/implementation/include/device_manager_service_impl.h
+++ b/services/implementation/include/device_manager_service_impl.h
@@ -270,7 +270,7 @@ private:
     void GetDelACLInfoVec(const int32_t &accessTokenId,
         std::vector<DistributedDeviceProfile::AccessControlProfile> &profiles,
         std::vector<std::pair<int32_t, std::string>> &delACLInfoVec, std::vector<int32_t> &userIdVec,
-        const uint32_t &userId);
+        const int32_t &userId);
 
     void DeleteAclByDelProfileMap(
         const std::map<int64_t, DistributedDeviceProfile::AccessControlProfile> &delProfileMap,
@@ -300,6 +300,7 @@ private:
         const std::string &deviceId, int32_t reason);
     void GetBundleName(const DMAclQuadInfo &info, std::set<std::string> &pkgNameSet);
     void DeleteSessionKey(int32_t userId, const DistributedDeviceProfile::AccessControlProfile &profile);
+    bool IsSessionExists(const std::string& deviceId, int32_t &sessionId);
 private:
     std::shared_ptr<AuthManagerBase> authMgr_;     // Old protocol only
 
@@ -317,11 +318,15 @@ private:
     sptr<DpInitedCallback> dpInitedCallback_ = nullptr;
 
     // The session ID corresponding to the device ID, used only on the src side
+    std::mutex deviceId2SessionIdMapMtx_;
     std::map<std::string, int> deviceId2SessionIdMap_;
+    std::mutex sessionsMapMtx_;
     std::map<int, std::shared_ptr<Session>> sessionsMap_;  // sessionId corresponds to the session object
+    std::mutex deviceIdMutexMapMtx_;
     std::map<std::string, std::mutex> deviceIdMutexMap_;  // Lock corresponding to the device ID
-    std::mutex mapMutex_;  // sessionsMap_ lock
+    std::mutex sessionEnableCvMapMtx_;
     std::map<int, std::condition_variable> sessionEnableCvMap_;  // Condition variable corresponding to the session
+    std::mutex sessionEnableMutexMapMtx_;
     std::map<int, std::mutex> sessionEnableMutexMap_;      // Lock corresponding to the session
     std::map<int, bool> sessionEnableCvReadyMap_;  // Condition variable ready flag
     std::mutex logicalSessionId2TokenIdMapMtx_;
diff --git a/services/implementation/src/device_manager_service_impl.cpp b/services/implementation/src/device_manager_service_impl.cpp
index 75dfdec64fd6d69d66349e33d53d2b93ba2d74d8..fa5f538504e02936d7997aee158a7d78273e1a93 100644
--- a/services/implementation/src/device_manager_service_impl.cpp
+++ b/services/implementation/src/device_manager_service_impl.cpp
@@ -328,13 +328,18 @@ void DeviceManagerServiceImpl::CleanSessionMap(int sessionId, std::shared_ptr<Se
         usleep(USLEEP_TIME_US_500000);
         CHECK_NULL_VOID(softbusConnector_);
         softbusConnector_->GetSoftbusSession()->CloseAuthSession(sessionId);
-        std::lock_guard<std::mutex> lock(mapMutex_);
-        if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            sessionsMap_[sessionId] = nullptr;
-            sessionsMap_.erase(sessionId);
+        {
+            std::lock_guard<std::mutex> lock(sessionsMapMtx_);
+            if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
+                sessionsMap_[sessionId] = nullptr;
+                sessionsMap_.erase(sessionId);
+            }
         }
-        if (deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) {
-            deviceId2SessionIdMap_.erase(session->deviceId_);
+        {
+            std::lock_guard<std::mutex> sessionMapLock(deviceId2SessionIdMapMtx_);
+            if (deviceId2SessionIdMap_.find(session->deviceId_) != deviceId2SessionIdMap_.end()) {
+                deviceId2SessionIdMap_.erase(session->deviceId_);
+            }
         }
     }
     return;
@@ -504,10 +509,13 @@ void DeviceManagerServiceImpl::ReleaseMaps()
         }
         authMgrMap_.clear();
     }
-    for (auto& pair : sessionsMap_) {
-        pair.second = nullptr;
+    {
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
+        for (auto& pair : sessionsMap_) {
+            pair.second = nullptr;
+        }
+        sessionsMap_.clear();
     }
-    sessionsMap_.clear();
     {
         std::lock_guard<std::mutex> configsLock(configsMapMutex_);
         for (auto& pair : configsMap_) {
@@ -515,10 +523,22 @@ void DeviceManagerServiceImpl::ReleaseMaps()
         }
         configsMap_.clear();
     }
-    deviceId2SessionIdMap_.clear();
-    deviceIdMutexMap_.clear();
-    sessionEnableMutexMap_.clear();
-    sessionEnableCvMap_.clear();
+    {
+        std::lock_guard<std::mutex> sessionMapLock(deviceId2SessionIdMapMtx_);
+        deviceId2SessionIdMap_.clear();
+    }
+    {
+        std::lock_guard<std::mutex> deviceMapLock(deviceIdMutexMapMtx_);
+        deviceIdMutexMap_.clear();
+    }
+    {
+        std::lock_guard<std::mutex> sessionEnableMapLock(sessionEnableMutexMapMtx_);
+        sessionEnableMutexMap_.clear();
+    }
+    {
+        std::lock_guard<std::mutex> sessionCvMapLock(sessionEnableCvMapMtx_);
+        sessionEnableCvMap_.clear();
+    }
     {
         std::lock_guard<std::mutex> tokenIdLock(logicalSessionId2TokenIdMapMtx_);
         logicalSessionId2TokenIdMap_.clear();
@@ -857,7 +877,7 @@ int DeviceManagerServiceImpl::OnSessionOpened(int sessionId, int result)
 
     // Get the remote deviceId, sink end gives sessionsMap[deviceId] = session;
     {
-        std::lock_guard<std::mutex> lock(mapMutex_);
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
         if (sessionsMap_.find(sessionId) == sessionsMap_.end()) {
             sessionsMap_[sessionId] = std::make_shared<Session>(sessionId, peerUdid);
         }
@@ -891,7 +911,7 @@ std::shared_ptr<Session> DeviceManagerServiceImpl::GetCurSession(int sessionId)
     std::shared_ptr<Session> curSession = nullptr;
     // Get the remote deviceId, sink end gives sessionsMap[deviceId] = session;
     {
-        std::lock_guard<std::mutex> lock(mapMutex_);
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
         if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
             curSession = sessionsMap_[sessionId];
         } else {
@@ -1536,43 +1556,48 @@ int DeviceManagerServiceImpl::OpenAuthSession(const std::string& deviceId,
     }
 }
 
-std::shared_ptr<Session> DeviceManagerServiceImpl::GetOrCreateSession(const std::string& deviceId,
-    const std::map<std::string, std::string> &bindParam)
+bool DeviceManagerServiceImpl::IsSessionExists(const std::string& deviceId, int32_t &sessionId)
 {
-    std::shared_ptr<Session> instance;
-    int sessionId = -1;
-    // Acquire global lock to ensure thread safety for maps
     {
-        std::lock_guard<std::mutex> lock(mapMutex_);
+        std::lock_guard<std::mutex> sessionMapLock(deviceId2SessionIdMapMtx_);
         if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) {
             sessionId = deviceId2SessionIdMap_[deviceId];
         }
+    }
+    {
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
         if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            return sessionsMap_[sessionId];
+            return true;
         }
     }
+    return false;
+}
 
-    // Get the lock corresponding to deviceId
+std::shared_ptr<Session> DeviceManagerServiceImpl::GetOrCreateSession(const std::string& deviceId,
+    const std::map<std::string, std::string> &bindParam)
+{
+    std::shared_ptr<Session> instance;
+    int sessionId = -1;
+    // Acquire global lock to ensure thread safety for maps
+    if (IsSessionExists(deviceId, sessionId)) {
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
+        return sessionsMap_[sessionId];
+    }
+    std::lock_guard<std::mutex> deviceMapLock(deviceIdMutexMapMtx_);
     std::mutex& device_mutex = deviceIdMutexMap_[deviceId];
     std::lock_guard<std::mutex> lock(device_mutex);
-
     // Check again whether the corresponding object already exists (because other threads may have created it during
     //  the lock acquisition in the previous step)
+    if (IsSessionExists(deviceId, sessionId)) {
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
+        return sessionsMap_[sessionId];
+    }
+    sessionId = OpenAuthSession(deviceId, bindParam);
+    if (sessionId < 0) {
+        LOGE("OpenAuthSession failed, stop the authentication");
+        return nullptr;
+    }
     {
-        std::lock_guard<std::mutex> lock(mapMutex_);
-        if (deviceId2SessionIdMap_.find(deviceId) != deviceId2SessionIdMap_.end()) {
-            sessionId = deviceId2SessionIdMap_[deviceId];
-        }
-        if (sessionsMap_.find(sessionId) != sessionsMap_.end()) {
-            return sessionsMap_[sessionId];
-        }
-
-        sessionId = OpenAuthSession(deviceId, bindParam);
-        if (sessionId < 0) {
-            LOGE("OpenAuthSession failed, stop the authentication");
-            return nullptr;
-        }
-
         std::unique_lock<std::mutex> cvLock(sessionEnableMutexMap_[sessionId]);
         sessionEnableCvReadyMap_[sessionId] = false;
         if (sessionEnableCvMap_[sessionId].wait_for(cvLock, std::chrono::milliseconds(OPEN_AUTH_SESSION_TIMEOUT),
@@ -1583,8 +1608,14 @@ std::shared_ptr<Session> DeviceManagerServiceImpl::GetOrCreateSession(const std:
             return nullptr;
         }
         sessionEnableCvReadyMap_.erase(sessionId);
-        instance = std::make_shared<Session>(sessionId, deviceId);
+    }
+    instance = std::make_shared<Session>(sessionId, deviceId);
+    {
+        std::lock_guard<std::mutex> sessionMapLock(deviceId2SessionIdMapMtx_);
         deviceId2SessionIdMap_[deviceId] = sessionId;
+    }
+    {
+        std::lock_guard<std::mutex> lock(sessionsMapMtx_);
         sessionsMap_[sessionId] = instance;
     }
     return instance;
@@ -2485,7 +2516,7 @@ void DeviceManagerServiceImpl::DeleteAclByTokenId(const int32_t accessTokenId,
 void DeviceManagerServiceImpl::GetDelACLInfoVec(const int32_t &accessTokenId,
     std::vector<DistributedDeviceProfile::AccessControlProfile> &profiles,
     std::vector<std::pair<int32_t, std::string>> &delACLInfoVec, std::vector<int32_t> &userIdVec,
-    const uint32_t &userId)
+    const int32_t &userId)
 {
     std::map<int64_t, DistributedDeviceProfile::AccessControlProfile> delProfileMap;
     char localDeviceId[DEVICE_UUID_LENGTH] = {0};