diff --git a/services/accesstokenmanager/main/cpp/include/database/access_token_db.h b/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
index 138e645e076d25b3208e40c4394e96c95d63dcfb..80699403f9bbb36809276c0f58e2063455d43cc0 100644
--- a/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
+++ b/services/accesstokenmanager/main/cpp/include/database/access_token_db.h
@@ -16,6 +16,7 @@
 #ifndef ACCESS_TOKEN_DB_H
 #define ACCESS_TOKEN_DB_H
 
+#include <shared_mutex>
 #include <vector>
 
 #include "access_token.h"
@@ -24,7 +25,6 @@
 #include "generic_values.h"
 #include "rdb_predicates.h"
 #include "rdb_store.h"
-#include "rwlock.h"
 #include "singleton.h"
 
 namespace OHOS {
@@ -61,7 +61,7 @@ private:
 
     int32_t RestoreAndCommitIfCorrupt(const int32_t resultCode, const std::shared_ptr<NativeRdb::RdbStore>& db);
 
-    OHOS::Utils::RWLock rwLock_;
+    std::shared_mutex rwLock_;
     std::shared_ptr<NativeRdb::RdbStore> db_ = nullptr;
     std::mutex dbLock_;
 };
diff --git a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_id_manager.h b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_id_manager.h
index c4e8bb678e60b6d899f1bf18694356f3ba7e7106..5ae319f6160f86e8de381accd4c52e7be83d4f0e 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_id_manager.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_id_manager.h
@@ -17,11 +17,11 @@
 #define ACCESSTOKEN_TOKEN_ID_MANAGER_H
 
 #include <set>
+#include <shared_mutex>
 #include <vector>
 
 #include "access_token.h"
 #include "nocopyable.h"
-#include "rwlock.h"
 
 namespace OHOS {
 namespace Security {
@@ -44,7 +44,7 @@ private:
     DISALLOW_COPY_AND_MOVE(AccessTokenIDManager);
     AccessTokenID CreateTokenId(ATokenTypeEnum type, int32_t dlpFlag, int32_t cloneFlag) const;
 
-    OHOS::Utils::RWLock tokenIdLock_;
+    std::shared_mutex tokenIdLock_;
     std::set<AccessTokenID> tokenIdSet_;
 };
 } // namespace AccessToken
diff --git a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_info_manager.h b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_info_manager.h
index 4e60ebb7df25a33a8518fbeaa68474fac71ca7ed..cd1675179ba0c0a62a5cfb2289a95f35046c41b5 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_info_manager.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_info_manager.h
@@ -20,6 +20,7 @@
 #include <atomic>
 #include <map>
 #include <memory>
+#include <shared_mutex>
 #include <unordered_set>
 #include <vector>
 
@@ -147,16 +148,16 @@ private:
     std::shared_ptr<HapTokenInfoInner> GetHapTokenInfoInnerFromDb(AccessTokenID id);
     bool hasInited_;
 
-    OHOS::Utils::RWLock hapTokenInfoLock_;
-    OHOS::Utils::RWLock nativeTokenInfoLock_;
-    OHOS::Utils::RWLock managerLock_;
-    OHOS::Utils::RWLock modifyLock_;
+    std::shared_mutex hapTokenInfoLock_;
+    std::shared_mutex nativeTokenInfoLock_;
+    std::shared_mutex managerLock_;
+    std::shared_mutex modifyLock_;
 
     std::map<int, std::shared_ptr<HapTokenInfoInner>> hapTokenInfoMap_;
     std::map<std::string, AccessTokenID> hapTokenIdMap_;
     std::map<uint32_t, NativeTokenInfoCache> nativeTokenInfoMap_;
 
-    OHOS::Utils::RWLock userPolicyLock_;
+    std::shared_mutex userPolicyLock_;
     std::vector<int32_t> inactiveUserList_;
     std::vector<std::string> permPolicyList_;
 };
diff --git a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_remote_token_manager.h b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_remote_token_manager.h
index 80637308f694872238e03816b1e9330726c898b5..d9406d4965f5666df0f05befb41cd93350da654d 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/accesstoken_remote_token_manager.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/accesstoken_remote_token_manager.h
@@ -18,13 +18,13 @@
 
 #include <map>
 #include <memory>
+#include <shared_mutex>
 #include <vector>
 
 #include "access_token.h"
 #include "hap_token_info.h"
 #include "hap_token_info_inner.h"
 #include "nocopyable.h"
-#include "rwlock.h"
 
 namespace OHOS {
 namespace Security {
@@ -48,7 +48,7 @@ private:
     AccessTokenRemoteTokenManager();
     DISALLOW_COPY_AND_MOVE(AccessTokenRemoteTokenManager);
 
-    OHOS::Utils::RWLock remoteDeviceLock_;
+    std::shared_mutex remoteDeviceLock_;
     std::map<std::string, AccessTokenRemoteDevice> remoteDeviceMap_;
 };
 } // namespace AccessToken
diff --git a/services/accesstokenmanager/main/cpp/include/permission/hap_token_info_inner.h b/services/accesstokenmanager/main/cpp/include/permission/hap_token_info_inner.h
index 8f69edb9abc648652873191ef1ecf2debad54e92..c88fabde1316fb918af131fdeb11a99b5216e0fc 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/hap_token_info_inner.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/hap_token_info_inner.h
@@ -17,6 +17,7 @@
 #define ACCESSTOKEN_HAP_TOKEN_INFO_INNER_H
 
 #include <memory>
+#include <shared_mutex>
 #include <string>
 #include <vector>
 
@@ -26,7 +27,6 @@
 #include "permission_data_brief.h"
 #include "permission_def.h"
 #include "permission_status.h"
-#include "rwlock.h"
 
 namespace OHOS {
 namespace Security {
@@ -110,7 +110,7 @@ private:
     /** permission dialog is forbidden */
     bool isPermDialogForbidden_ = false;
 
-    OHOS::Utils::RWLock policySetLock_;
+    std::shared_mutex policySetLock_;
 };
 } // namespace AccessToken
 } // namespace Security
diff --git a/services/accesstokenmanager/main/cpp/include/permission/permission_data_brief.h b/services/accesstokenmanager/main/cpp/include/permission/permission_data_brief.h
index 0c39e1ade74446d58486665e25eef38d14458d26..8904b7306f50d8b7315076278a264c002af3fffc 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/permission_data_brief.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/permission_data_brief.h
@@ -21,14 +21,15 @@
 #include <memory>
 #include <mutex>
 #include <map>
+#include <shared_mutex>
 #include <string>
 #include <vector>
+
 #include "access_token.h"
 #include "permission_status.h"
 #include "generic_values.h"
 #include "hap_token_info.h"
-
-#include "rwlock.h"
+#include "nocopyable.h"
 
 namespace OHOS {
 namespace Security {
@@ -111,7 +112,7 @@ private:
     void DeleteExtendedValue(AccessTokenID tokenID);
     PermissionDataBrief() = default;
     DISALLOW_COPY_AND_MOVE(PermissionDataBrief);
-    OHOS::Utils::RWLock permissionStateDataLock_;
+    std::shared_mutex permissionStateDataLock_;
     std::map<uint32_t, std::vector<BriefPermData>> requestedPermData_;
     std::map<uint64_t, std::string> extendedValue_;
     std::list<BriefSecCompData> secCompList_;
diff --git a/services/accesstokenmanager/main/cpp/include/permission/permission_manager.h b/services/accesstokenmanager/main/cpp/include/permission/permission_manager.h
index 7dbf07dd273e4e08d071beebf90e666a767a0a12..6284473c07e642a2f823c8b630ed020d4cabb018 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/permission_manager.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/permission_manager.h
@@ -18,6 +18,7 @@
 
 #include <mutex>
 #include <vector>
+#include <shared_mutex>
 #include <string>
 
 #include "ability_manager_access_loader.h"
@@ -26,6 +27,7 @@
 #include "hap_token_info_inner.h"
 #include "iremote_broker.h"
 #include "libraryloader.h"
+#include "nocopyable.h"
 #include "permission_def.h"
 #include "permission_grant_event.h"
 #include "permission_list_state.h"
@@ -35,9 +37,6 @@
 #include "permission_status.h"
 #include "temp_permission_observer.h"
 
-#include "rwlock.h"
-#include "nocopyable.h"
-
 namespace OHOS {
 namespace Security {
 namespace AccessToken {
@@ -146,13 +145,12 @@ private:
     static std::recursive_mutex mutex_;
     static PermissionManager* implInstance_;
 
-    OHOS::Utils::RWLock permParamSetLock_;
+    std::shared_mutex permParamSetLock_;
     uint64_t paramValue_ = 0;
 
-    OHOS::Utils::RWLock permFlagParamSetLock_;
+    std::shared_mutex permFlagParamSetLock_;
     uint64_t paramFlagValue_ = 0;
 
-    OHOS::Utils::RWLock permToggleStateLock_;
     DISALLOW_COPY_AND_MOVE(PermissionManager);
 
     std::mutex abilityManagerMutex_;
diff --git a/services/accesstokenmanager/main/cpp/include/permission/token_modify_notifier.h b/services/accesstokenmanager/main/cpp/include/permission/token_modify_notifier.h
index 72303a3776abdb8151ce2ebfbfca0989029549ac..fb0ee6f56108984d9ffec90252a0f7a47098d55f 100644
--- a/services/accesstokenmanager/main/cpp/include/permission/token_modify_notifier.h
+++ b/services/accesstokenmanager/main/cpp/include/permission/token_modify_notifier.h
@@ -18,14 +18,14 @@
 
 #include <atomic>
 #include <set>
+#include <shared_mutex>
 #include <vector>
 
 #include "access_token.h"
+#include "callback_death_recipients.h"
 #include "i_token_sync_callback.h"
 #include "nocopyable.h"
-#include "rwlock.h"
 #include "thread_pool.h"
-#include "callback_death_recipients.h"
 
 namespace OHOS {
 namespace Security {
@@ -48,9 +48,9 @@ private:
     DISALLOW_COPY_AND_MOVE(TokenModifyNotifier);
 
     bool hasInited_;
-    OHOS::Utils::RWLock initLock_;
-    OHOS::Utils::RWLock listLock_;
-    OHOS::Utils::RWLock notifyLock_;
+    std::shared_mutex initLock_;
+    std::shared_mutex listLock_;
+    std::shared_mutex notifyLock_;
     OHOS::ThreadPool notifyTokenWorker_;
     std::set<AccessTokenID> observationSet_;
     std::vector<AccessTokenID> deleteTokenList_;
diff --git a/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp b/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
index 45e1db280a9eaf16ed39cbb9b3d1d157699666f7..c761806d953579616db591e746f5ca5197656d50 100644
--- a/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
+++ b/services/accesstokenmanager/main/cpp/src/database/access_token_db.cpp
@@ -256,7 +256,7 @@ int32_t AccessTokenDb::Modify(const AtmDataType type, const GenericValues& modif
 
     int32_t changedRows = 0;
     {
-        OHOS::Utils::UniqueWriteGuard<OHOS::Utils::RWLock> lock(this->rwLock_);
+        std::unique_lock<std::shared_mutex> lock(this->rwLock_);
         auto db = GetRdb();
         if (db == nullptr) {
             LOGC(ATM_DOMAIN, ATM_TAG, "Db is nullptr.");
@@ -334,7 +334,7 @@ int32_t AccessTokenDb::Find(AtmDataType type, const GenericValues& conditionValu
     std::vector<std::string> columns; // empty columns means query all columns
     int count = 0;
     {
-        OHOS::Utils::UniqueReadGuard<OHOS::Utils::RWLock> lock(this->rwLock_);
+        std::shared_lock<std::shared_mutex> lock(this->rwLock_);
         auto db = GetRdb();
         if (db == nullptr) {
             LOGC(ATM_DOMAIN, ATM_TAG, "Db is nullptr.");
@@ -403,7 +403,7 @@ int32_t AccessTokenDb::DeleteAndInsertValues(const std::vector<DelInfo>& delInfo
     int64_t beginTime = TimeUtil::GetCurrentTimestamp();
 
     {
-        OHOS::Utils::UniqueWriteGuard<OHOS::Utils::RWLock> lock(this->rwLock_);
+        std::unique_lock<std::shared_mutex> lock(this->rwLock_);
         std::shared_ptr<NativeRdb::RdbStore> db = GetRdb();
         if (db == nullptr) {
             LOGC(ATM_DOMAIN, ATM_TAG, "Db is nullptr.");
diff --git a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_id_manager.cpp b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_id_manager.cpp
index 1c3e3a3f902ae8b91e32bd0180422c037c3e27a5..c1c99fe39180eca54c83a169e12c2902cced1986 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_id_manager.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_id_manager.cpp
@@ -31,7 +31,7 @@ std::recursive_mutex g_instanceMutex;
 ATokenTypeEnum AccessTokenIDManager::GetTokenIdType(AccessTokenID id)
 {
     {
-        Utils::UniqueReadGuard<Utils::RWLock> idGuard(this->tokenIdLock_);
+        std::shared_lock<std::shared_mutex> idGuard(this->tokenIdLock_);
         if (tokenIdSet_.count(id) == 0) {
             return TOKEN_INVALID;
         }
@@ -46,7 +46,7 @@ int AccessTokenIDManager::RegisterTokenId(AccessTokenID id, ATokenTypeEnum type)
         return ERR_PARAM_INVALID;
     }
 
-    Utils::UniqueWriteGuard<Utils::RWLock> idGuard(this->tokenIdLock_);
+    std::unique_lock<std::shared_mutex> idGuard(this->tokenIdLock_);
 
     for (std::set<AccessTokenID>::iterator it = tokenIdSet_.begin(); it != tokenIdSet_.end(); ++it) {
         AccessTokenID tokenId = *it;
@@ -105,7 +105,7 @@ AccessTokenID AccessTokenIDManager::CreateAndRegisterTokenId(ATokenTypeEnum type
 
 void AccessTokenIDManager::ReleaseTokenId(AccessTokenID id)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> idGuard(this->tokenIdLock_);
+    std::unique_lock<std::shared_mutex> idGuard(this->tokenIdLock_);
     if (tokenIdSet_.count(id) == 0) {
         LOGI(ATM_DOMAIN, ATM_TAG, "Id %{public}x is not exist", id);
         return;
diff --git a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_info_manager.cpp b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_info_manager.cpp
index 9ce57f9c87b185e631f43865ed1ee9028fc5ade2..4c764367541087c255be3c9480c5dcff56240fe4 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_info_manager.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_info_manager.cpp
@@ -89,7 +89,7 @@ AccessTokenInfoManager::~AccessTokenInfoManager()
 void AccessTokenInfoManager::Init(uint32_t& hapSize, uint32_t& nativeSize, uint32_t& pefDefSize, uint32_t& dlpSize,
     std::map<int32_t, TokenIdInfo>& tokenIdAplMap)
 {
-    OHOS::Utils::UniqueWriteGuard<OHOS::Utils::RWLock> lk(this->managerLock_);
+    std::unique_lock<std::shared_mutex> lk(this->managerLock_);
     if (hasInited_) {
         return;
     }
@@ -265,7 +265,7 @@ int AccessTokenInfoManager::AddHapTokenInfo(const std::shared_ptr<HapTokenInfoIn
     AccessTokenID id = info->GetTokenID();
     AccessTokenID idRemoved = INVALID_TOKENID;
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         if (hapTokenInfoMap_.count(id) > 0) {
             LOGC(ATM_DOMAIN, ATM_TAG, "Token %{public}u info has exist.", id);
             return AccessTokenError::ERR_TOKENID_HAS_EXISTED;
@@ -289,7 +289,7 @@ int AccessTokenInfoManager::AddHapTokenInfo(const std::shared_ptr<HapTokenInfoIn
     // add hap to kernel
     int32_t userId = info->GetUserID();
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         if (!permPolicyList_.empty() &&
             (std::find(inactiveUserList_.begin(), inactiveUserList_.end(), userId) != inactiveUserList_.end())) {
             LOGI(ATM_DOMAIN, ATM_TAG, "Execute user policy.");
@@ -339,7 +339,7 @@ std::shared_ptr<HapTokenInfoInner> AccessTokenInfoManager::GetHapTokenInfoInnerF
         return nullptr;
     }
 
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     (void)AccessTokenIDManager::GetInstance().RegisterTokenId(id, TOKEN_HAP);
     hapTokenIdMap_[GetHapUniqueStr(hap)] = id;
     hapTokenInfoMap_[id] = hap;
@@ -353,7 +353,7 @@ std::shared_ptr<HapTokenInfoInner> AccessTokenInfoManager::GetHapTokenInfoInnerF
 std::shared_ptr<HapTokenInfoInner> AccessTokenInfoManager::GetHapTokenInfoInner(AccessTokenID id)
 {
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         auto iter = hapTokenInfoMap_.find(id);
         if (iter != hapTokenInfoMap_.end()) {
             return iter->second;
@@ -364,7 +364,7 @@ std::shared_ptr<HapTokenInfoInner> AccessTokenInfoManager::GetHapTokenInfoInner(
 
 int32_t AccessTokenInfoManager::GetHapTokenDlpType(AccessTokenID id)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     auto iter = hapTokenInfoMap_.find(id);
     if ((iter != hapTokenInfoMap_.end()) && (iter->second != nullptr)) {
         return iter->second->GetDlpType();
@@ -376,13 +376,13 @@ int32_t AccessTokenInfoManager::GetHapTokenDlpType(AccessTokenID id)
 bool AccessTokenInfoManager::IsTokenIdExist(AccessTokenID id)
 {
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         if (hapTokenInfoMap_.count(id) != 0) {
             return true;
         }
     }
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
         if (nativeTokenInfoMap_.count(id) != 0) {
             return true;
         }
@@ -426,7 +426,7 @@ int AccessTokenInfoManager::GetHapTokenInfo(AccessTokenID tokenID, HapTokenInfo&
 
 int AccessTokenInfoManager::GetNativeTokenInfo(AccessTokenID tokenID, NativeTokenInfoBase& info)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
     auto iter = nativeTokenInfoMap_.find(tokenID);
     if (iter == nativeTokenInfoMap_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Id %{public}u is not exist.", tokenID);
@@ -446,7 +446,7 @@ int AccessTokenInfoManager::RemoveHapTokenInfo(AccessTokenID id)
     }
     std::shared_ptr<HapTokenInfoInner> info;
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         // remove hap to kernel
         PermissionManager::GetInstance().RemovePermFromKernel(id);
         AccessTokenIDManager::GetInstance().ReleaseTokenId(id);
@@ -495,7 +495,7 @@ int AccessTokenInfoManager::RemoveNativeTokenInfo(AccessTokenID id)
     }
 
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
         if (nativeTokenInfoMap_.count(id) == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Native token %{public}u is null.", id);
             return ERR_TOKENID_NOT_EXIST;
@@ -644,7 +644,7 @@ int AccessTokenInfoManager::AllocAccessTokenIDEx(
 
 AccessTokenIDEx AccessTokenInfoManager::GetHapTokenID(int32_t userID, const std::string& bundleName, int32_t instIndex)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     std::string HapUniqueKey = GetHapUniqueStr(userID, bundleName, instIndex);
     AccessTokenIDEx tokenIdEx = {0};
     auto iter = hapTokenIdMap_.find(HapUniqueKey);
@@ -696,7 +696,7 @@ void AccessTokenInfoManager::InitNativeTokenInfos(const std::vector<NativeTokenI
         std::vector<bool> statusList;
         GetNativePermissionList(info, opCodeList, statusList);
         // add native token info to cache
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
         NativeTokenInfoCache cache;
         cache.processName = process;
         cache.apl = static_cast<ATokenAplEnum>(info.apl);
@@ -741,7 +741,7 @@ int32_t AccessTokenInfoManager::UpdateHapToken(AccessTokenIDEx& tokenIdEx, const
         tokenIdEx.tokenIdExStruct.tokenAttr &= ~ATOMIC_SERVICE_FLAG;
     }
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         infoPtr->Update(info, permStateList, hapPolicy);
     }
 
@@ -766,7 +766,7 @@ int32_t AccessTokenInfoManager::UpdateHapToken(AccessTokenIDEx& tokenIdEx, const
 void AccessTokenInfoManager::UpdateHapToKernel(AccessTokenID tokenID, int32_t userId)
 {
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         if (!permPolicyList_.empty() &&
             (std::find(inactiveUserList_.begin(), inactiveUserList_.end(), userId) != inactiveUserList_.end())) {
             LOGI(ATM_DOMAIN, ATM_TAG, "Execute user policy.");
@@ -804,7 +804,7 @@ int AccessTokenInfoManager::UpdateRemoteHapTokenInfo(AccessTokenID mapID, HapTok
         LOGI(ATM_DOMAIN, ATM_TAG, "Token %{public}u is null or not remote, can not update!", mapID);
         return ERR_IDENTITY_CHECK_FAILED;
     }
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     infoPtr->UpdateRemoteHapTokenInfo(mapID, hapSync.baseInfo, hapSync.permStateList);
     // update remote hap to kernel
     PermissionManager::GetInstance().AddHapPermToKernel(mapID, std::vector<std::string>());
@@ -919,14 +919,14 @@ int AccessTokenInfoManager::DeleteRemoteToken(const std::string& deviceID, Acces
 
     ATokenTypeEnum type = TokenIDAttributes::GetTokenIdTypeEnum(mapID);
     if (type == TOKEN_HAP) {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
         if (hapTokenInfoMap_.count(mapID) == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Hap token %{public}u no exist.", mapID);
             return ERR_TOKEN_INVALID;
         }
         hapTokenInfoMap_.erase(mapID);
     } else if ((type == TOKEN_NATIVE) || (type == TOKEN_SHELL)) {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
         if (nativeTokenInfoMap_.count(mapID) == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Native token %{public}u is null.", mapID);
             return ERR_TOKEN_INVALID;
@@ -1154,7 +1154,7 @@ void AccessTokenInfoManager::PermissionStateNotify(const std::shared_ptr<HapToke
     std::vector<std::string> permissionList;
     int32_t userId = info->GetUserID();
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         if (!permPolicyList_.empty() &&
             (std::find(inactiveUserList_.begin(), inactiveUserList_.end(), userId) != inactiveUserList_.end())) {
             LOGI(ATM_DOMAIN, ATM_TAG, "Execute user policy.");
@@ -1201,7 +1201,7 @@ int32_t AccessTokenInfoManager::GetHapAppIdByTokenId(AccessTokenID tokenID, std:
 AccessTokenID AccessTokenInfoManager::GetNativeTokenId(const std::string& processName)
 {
     AccessTokenID tokenID = INVALID_TOKENID;
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
     for (auto iter = nativeTokenInfoMap_.begin(); iter != nativeTokenInfoMap_.end(); ++iter) {
         if (iter->second.processName == processName) {
             tokenID = iter->first;
@@ -1228,7 +1228,7 @@ void AccessTokenInfoManager::DumpHapTokenInfoByTokenId(const AccessTokenID token
 
 void AccessTokenInfoManager::DumpHapTokenInfoByBundleName(const std::string& bundleName, std::string& dumpInfo)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> hapInfoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> hapInfoGuard(this->hapTokenInfoLock_);
     for (auto iter = hapTokenInfoMap_.begin(); iter != hapTokenInfoMap_.end(); iter++) {
         if (iter->second != nullptr) {
             if (bundleName != iter->second->GetBundleName()) {
@@ -1244,7 +1244,7 @@ void AccessTokenInfoManager::DumpAllHapTokenname(std::string& dumpInfo)
 {
     LOGD(ATM_DOMAIN, ATM_TAG, "Get all hap token name.");
 
-    Utils::UniqueReadGuard<Utils::RWLock> hapInfoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> hapInfoGuard(this->hapTokenInfoLock_);
     for (auto iter = hapTokenInfoMap_.begin(); iter != hapTokenInfoMap_.end(); iter++) {
         if (iter->second != nullptr) {
             dumpInfo += std::to_string(iter->second->GetTokenID()) + ": " + iter->second->GetBundleName();
@@ -1262,7 +1262,7 @@ void AccessTokenInfoManager::DumpAllNativeTokenName(std::string& dumpInfo)
 {
     LOGD(ATM_DOMAIN, ATM_TAG, "Get all native token name.");
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
     for (auto iter = nativeTokenInfoMap_.begin(); iter != nativeTokenInfoMap_.end(); iter++) {
         dumpInfo += std::to_string(iter->first) + ": " + iter->second.processName;
         dumpInfo.append("\n");
@@ -1333,7 +1333,7 @@ int32_t AccessTokenInfoManager::ClearUserGrantedPermission(AccessTokenID id)
 
     {
         int32_t userId = infoPtr->GetUserID();
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         if (!permPolicyList_.empty() &&
             (std::find(inactiveUserList_.begin(), inactiveUserList_.end(), userId) != inactiveUserList_.end())) {
             PermissionManager::GetInstance().AddHapPermToKernel(id, permPolicyList_);
@@ -1357,7 +1357,7 @@ bool AccessTokenInfoManager::IsPermissionRestrictedByUserPolicy(AccessTokenID id
         return true;
     }
     int32_t userId = infoPtr->GetUserID();
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
     if ((std::find(permPolicyList_.begin(), permPolicyList_.end(), permissionName) != permPolicyList_.end()) &&
         (std::find(inactiveUserList_.begin(), inactiveUserList_.end(), userId) != inactiveUserList_.end())) {
         LOGI(ATM_DOMAIN, ATM_TAG, "id %{public}u perm %{public}s.", id, permissionName.c_str());
@@ -1368,7 +1368,7 @@ bool AccessTokenInfoManager::IsPermissionRestrictedByUserPolicy(AccessTokenID id
 
 void AccessTokenInfoManager::GetRelatedSandBoxHapList(AccessTokenID tokenId, std::vector<AccessTokenID>& tokenIdList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
 
     auto infoIter = hapTokenInfoMap_.find(tokenId);
     if (infoIter == hapTokenInfoMap_.end()) {
@@ -1403,7 +1403,7 @@ void AccessTokenInfoManager::GetRelatedSandBoxHapList(AccessTokenID tokenId, std
 
 int32_t AccessTokenInfoManager::SetPermDialogCap(AccessTokenID tokenID, bool enable)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     auto infoIter = hapTokenInfoMap_.find(tokenID);
     if ((infoIter == hapTokenInfoMap_.end()) || (infoIter->second == nullptr)) {
         LOGE(ATM_DOMAIN, ATM_TAG, "HapTokenInfoInner is nullptr.");
@@ -1481,7 +1481,7 @@ int32_t AccessTokenInfoManager::ParseUserPolicyInfo(const std::vector<UserState>
 void AccessTokenInfoManager::GetGoalHapList(std::map<AccessTokenID, bool>& tokenIdList,
     std::map<int32_t, bool>& changedUserList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     for (auto iter = hapTokenInfoMap_.begin(); iter != hapTokenInfoMap_.end(); ++iter) {
         AccessTokenID tokenId = iter->first;
         std::shared_ptr<HapTokenInfoInner> infoPtr = iter->second;
@@ -1505,7 +1505,7 @@ int32_t AccessTokenInfoManager::UpdatePermissionStateToKernel(const std::map<Acc
         bool isActive = iter->second;
         // refresh under userPolicyLock_
         {
-            Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+            std::shared_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
             std::map<std::string, bool> refreshedPermList;
             HapTokenInfoInner::RefreshPermStateToKernel(permPolicyList_, isActive, tokenId, refreshedPermList);
 
@@ -1550,7 +1550,7 @@ int32_t AccessTokenInfoManager::InitUserPolicy(
 {
     std::map<AccessTokenID, bool> tokenIdList;
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         std::map<int32_t, bool> changedUserList;
         int32_t ret = ParseUserPolicyInfo(userList, permList, changedUserList);
         if (ret != RET_SUCCESS) {
@@ -1570,7 +1570,7 @@ int32_t AccessTokenInfoManager::UpdateUserPolicy(const std::vector<UserState>& u
     std::map<AccessTokenID, bool> tokenIdList;
     {
         std::map<int32_t, bool> changedUserList;
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
         int32_t ret = ParseUserPolicyInfo(userList, changedUserList);
         if (ret != RET_SUCCESS) {
             return ret;
@@ -1588,7 +1588,7 @@ int32_t AccessTokenInfoManager::ClearUserPolicy()
 {
     std::map<AccessTokenID, bool> tokenIdList;
     std::vector<std::string> permList;
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->userPolicyLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->userPolicyLock_);
     if (permPolicyList_.empty()) {
         LOGW(ATM_DOMAIN, ATM_TAG, "UserPolicy has been cleared.");
         return RET_SUCCESS;
@@ -1615,7 +1615,7 @@ bool AccessTokenInfoManager::GetPermDialogCap(AccessTokenID tokenID)
         LOGE(ATM_DOMAIN, ATM_TAG, "Invalid tokenId.");
         return true;
     }
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->hapTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->hapTokenInfoLock_);
     auto infoIter = hapTokenInfoMap_.find(tokenID);
     if ((infoIter == hapTokenInfoMap_.end()) || (infoIter->second == nullptr)) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenId is not exist in map.");
@@ -1654,7 +1654,7 @@ int AccessTokenInfoManager::VerifyNativeAccessToken(AccessTokenID tokenID, const
         return PERMISSION_DENIED;
     }
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->nativeTokenInfoLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->nativeTokenInfoLock_);
     auto iter = nativeTokenInfoMap_.find(tokenID);
     if (iter == nativeTokenInfoMap_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Id %{public}u is not exist.", tokenID);
diff --git a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_remote_token_manager.cpp b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_remote_token_manager.cpp
index abaf9ff073cb1a64ae3d308d930d244d857f42fb..7985a7c6ce6a96cd209b641dcae6fba788cdb63c 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/accesstoken_remote_token_manager.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/accesstoken_remote_token_manager.cpp
@@ -65,7 +65,7 @@ AccessTokenID AccessTokenRemoteTokenManager::MapRemoteDeviceTokenToLocal(const s
     int32_t cloneFlag = TokenIDAttributes::GetTokenIdCloneFlag(remoteID);
 
     AccessTokenID mapID = 0;
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->remoteDeviceLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->remoteDeviceLock_);
     std::map<AccessTokenID, AccessTokenID>* mapPtr = nullptr;
     if (remoteDeviceMap_.count(deviceID) > 0) {
         AccessTokenRemoteDevice& device = remoteDeviceMap_[deviceID];
@@ -101,7 +101,7 @@ int AccessTokenRemoteTokenManager::GetDeviceAllRemoteTokenID(const std::string&
         LOGE(ATM_DOMAIN, ATM_TAG, "Device %{public}s is valid.", ConstantCommon::EncryptDevId(deviceID).c_str());
         return AccessTokenError::ERR_PARAM_INVALID;
     }
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->remoteDeviceLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->remoteDeviceLock_);
     if (remoteDeviceMap_.count(deviceID) < 1) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Device %{public}s has not mapping.",
             ConstantCommon::EncryptDevId(deviceID).c_str());
@@ -125,7 +125,7 @@ AccessTokenID AccessTokenRemoteTokenManager::GetDeviceMappingTokenID(const std::
         return 0;
     }
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->remoteDeviceLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->remoteDeviceLock_);
     if (remoteDeviceMap_.count(deviceID) < 1 ||
         remoteDeviceMap_[deviceID].MappingTokenIDPairMap_.count(remoteID) < 1) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Device %{public}s has not mapping.",
@@ -145,7 +145,7 @@ int AccessTokenRemoteTokenManager::RemoveDeviceMappingTokenID(const std::string&
         return ERR_PARAM_INVALID;
     }
 
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->remoteDeviceLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->remoteDeviceLock_);
     if (remoteDeviceMap_.count(deviceID) < 1 ||
         remoteDeviceMap_[deviceID].MappingTokenIDPairMap_.count(remoteID) < 1) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Device %{public}s has not mapping.",
diff --git a/services/accesstokenmanager/main/cpp/src/permission/hap_token_info_inner.cpp b/services/accesstokenmanager/main/cpp/src/permission/hap_token_info_inner.cpp
index 91d7d5222e1743393b68eeb13afb6f626c07144f..0738dc8dc5f0fb1a1b744503a623a630ea001a4a 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/hap_token_info_inner.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/hap_token_info_inner.cpp
@@ -108,7 +108,7 @@ void HapTokenInfoInner::Update(const UpdateHapInfoParams& info, const std::vecto
     } else {
         tokenInfoBasic_.tokenAttr &= ~ATOMIC_SERVICE_FLAG;
     }
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->policySetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->policySetLock_);
     PermissionDataBrief::GetInstance().Update(tokenInfoBasic_.tokenID, permStateList, hapPolicy.aclExtendedMap);
 }
 
@@ -168,7 +168,7 @@ int HapTokenInfoInner::RestoreHapTokenInfo(AccessTokenID tokenId,
     if (ret != RET_SUCCESS) {
         return ret;
     }
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->policySetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->policySetLock_);
     PermissionDataBrief::GetInstance().RestorePermissionBriefData(tokenId, permStateRes, extendedPermRes);
     return RET_SUCCESS;
 }
@@ -194,7 +194,7 @@ void HapTokenInfoInner::StorePermissionPolicy(std::vector<GenericValues>& permSt
         LOGI(ATM_DOMAIN, ATM_TAG, "Token %{public}u is remote hap token, will not store.", tokenInfoBasic_.tokenID);
         return;
     }
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->policySetLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->policySetLock_);
     (void)PermissionDataBrief::GetInstance().StorePermissionBriefData(tokenInfoBasic_.tokenID, permStateValues);
 }
 
@@ -292,7 +292,7 @@ void HapTokenInfoInner::UpdateRemoteHapTokenInfo(AccessTokenID mapID,
 int32_t HapTokenInfoInner::UpdatePermissionStatus(
     const std::string& permissionName, bool isGranted, uint32_t flag, bool& statusChanged)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->policySetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->policySetLock_);
     int32_t ret = PermissionDataBrief::GetInstance().UpdatePermissionStatus(tokenInfoBasic_.tokenID,
         permissionName, isGranted, flag, statusChanged);
     if (ret != RET_SUCCESS) {
@@ -369,7 +369,7 @@ bool HapTokenInfoInner::UpdateStatesToDB(AccessTokenID tokenID, std::vector<Perm
 
 int32_t HapTokenInfoInner::ResetUserGrantPermissionStatus(void)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->policySetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->policySetLock_);
 
     int32_t ret = PermissionDataBrief::GetInstance().ResetUserGrantPermissionStatus(tokenInfoBasic_.tokenID);
     if (ret != RET_SUCCESS) {
diff --git a/services/accesstokenmanager/main/cpp/src/permission/permission_data_brief.cpp b/services/accesstokenmanager/main/cpp/src/permission/permission_data_brief.cpp
index cbfb0b69135a39e70b7a551188ed90cfa708e3e5..719d2a3f6f737e87b432a69c2c90d40c90d113a9 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/permission_data_brief.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/permission_data_brief.cpp
@@ -97,7 +97,7 @@ bool PermissionDataBrief::GetPermissionBriefData(
 void PermissionDataBrief::GetExtendedValueList(
     AccessTokenID tokenId, std::vector<PermissionWithValue>& extendedPermList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     return GetExtendedValueListInner(tokenId, extendedPermList);
 }
 
@@ -126,7 +126,7 @@ void PermissionDataBrief::GetExtendedValueListInner(
 int32_t PermissionDataBrief::GetKernelPermissions(
     AccessTokenID tokenId, std::vector<PermissionWithValue>& kernelPermList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
 
     std::vector<BriefPermData> list;
     int32_t ret = GetBriefPermDataByTokenIdInner(tokenId, list);
@@ -171,7 +171,7 @@ int32_t PermissionDataBrief::GetReqPermissionByName(
     AccessTokenID tokenId, const std::string& permissionName,
     std::string& value, bool tokenIdCheck)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     if (tokenIdCheck) {
         auto iter = requestedPermData_.find(tokenId);
         if (iter == requestedPermData_.end()) {
@@ -255,7 +255,7 @@ void PermissionDataBrief::AddPermToBriefPermission(
     }
 
     std::vector<BriefPermData> list;
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     GetPermissionBriefDataList(tokenId, permStateListRes, aclExtendedMap, list);
     AddBriefPermDataByTokenId(tokenId, list);
 }
@@ -298,7 +298,7 @@ void PermissionDataBrief::Update(
     AccessTokenID tokenId, const std::vector<PermissionStatus>& permStateList,
     const std::map<std::string, std::string>& aclExtendedMap)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     std::vector<PermissionStatus> permStateFilterList;
     PermissionValidator::FilterInvalidPermissionState(TOKEN_HAP, true, permStateList, permStateFilterList);
     LOGI(ATM_DOMAIN, ATM_TAG, "PermStateFilterList size: %{public}zu.", permStateFilterList.size());
@@ -346,7 +346,7 @@ int32_t PermissionDataBrief::TranslationIntoAclExtendedMap(
 void PermissionDataBrief::RestorePermissionBriefData(AccessTokenID tokenId,
     const std::vector<GenericValues>& permStateRes, const std::vector<GenericValues> extendedPermRes)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     std::vector<BriefPermData> list;
     std::map<std::string, std::string> aclExtendedMap;
     int result = TranslationIntoAclExtendedMap(tokenId, extendedPermRes, aclExtendedMap);
@@ -394,7 +394,7 @@ int32_t PermissionDataBrief::StorePermissionBriefData(AccessTokenID tokenId,
 {
     std::vector<BriefPermData> permBriefDatalist;
     {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
         int32_t ret = GetBriefPermDataByTokenIdInner(tokenId, permBriefDatalist);
         if (ret != RET_SUCCESS) {
             return ret;
@@ -530,7 +530,7 @@ int32_t PermissionDataBrief::UpdatePermissionStatus(AccessTokenID tokenId,
     }
     int32_t ret;
     int32_t oldStatus = VerifyPermissionStatus(tokenId, opCode);
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     if (!ConstantCommon::IsPermGrantedBySecComp(flag)) {
         ret = UpdatePermStateList(tokenId, opCode, isGranted, flag);
     } else {
@@ -544,7 +544,7 @@ int32_t PermissionDataBrief::UpdatePermissionStatus(AccessTokenID tokenId,
 
 int32_t PermissionDataBrief::ResetUserGrantPermissionStatus(AccessTokenID tokenID)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID %{public}d is not exist.", tokenID);
@@ -588,7 +588,7 @@ void PermissionDataBrief::DeleteExtendedValue(AccessTokenID tokenID)
 
 int32_t PermissionDataBrief::DeleteBriefPermDataByTokenId(AccessTokenID tokenID)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID %{public}d is not exist.", tokenID);
@@ -622,14 +622,14 @@ int32_t PermissionDataBrief::GetBriefPermDataByTokenIdInner(AccessTokenID tokenI
 
 int32_t PermissionDataBrief::GetBriefPermDataByTokenId(AccessTokenID tokenID, std::vector<BriefPermData>& list)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     return GetBriefPermDataByTokenIdInner(tokenID, list);
 }
 
 void PermissionDataBrief::GetGrantedPermByTokenId(AccessTokenID tokenID,
     const std::vector<std::string>& constrainedList, std::vector<std::string>& permissionList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID %{public}d is not exist.", tokenID);
@@ -661,7 +661,7 @@ void PermissionDataBrief::GetGrantedPermByTokenId(AccessTokenID tokenID,
 void PermissionDataBrief::GetPermStatusListByTokenId(AccessTokenID tokenID,
     const std::vector<uint32_t> constrainedList, std::vector<uint32_t>& opCodeList, std::vector<bool>& statusList)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID %{public}d is not exist.", tokenID);
@@ -698,7 +698,7 @@ void PermissionDataBrief::GetPermStatusListByTokenId(AccessTokenID tokenID,
 
 PermUsedTypeEnum PermissionDataBrief::GetPermissionUsedType(AccessTokenID tokenID, int32_t opCode)
 {
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID is not exist %{public}d.", tokenID);
@@ -762,7 +762,7 @@ int32_t PermissionDataBrief::VerifyPermissionStatus(AccessTokenID tokenID, const
         LOGE(ATM_DOMAIN, ATM_TAG, "PermissionName is invalid %{public}s.", permission.c_str());
         return PERMISSION_DENIED;
     }
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     return VerifyPermissionStatus(tokenID, opCode);
 }
 
@@ -774,7 +774,7 @@ bool PermissionDataBrief::IsPermissionGrantedWithSecComp(AccessTokenID tokenID,
         return false;
     }
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID is not exist %{public}d.", tokenID);
@@ -807,7 +807,7 @@ int32_t PermissionDataBrief::QueryPermissionFlag(AccessTokenID tokenID, const st
         return AccessTokenError::ERR_PERMISSION_NOT_EXIST;
     }
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID is invalid %{public}u.", tokenID);
@@ -833,7 +833,7 @@ void PermissionDataBrief::SecCompGrantedPermListUpdated(
         return;
     }
 
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenID);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID is invalid %{public}u.", tokenID);
@@ -873,7 +873,7 @@ void PermissionDataBrief::SecCompGrantedPermListUpdated(
 
 void PermissionDataBrief::ClearAllSecCompGrantedPerm()
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     std::list<BriefSecCompData>::iterator secCompData;
     for (secCompData = secCompList_.begin(); secCompData != secCompList_.end();) {
         secCompData = secCompList_.erase(secCompData);
@@ -910,7 +910,7 @@ int32_t PermissionDataBrief::RefreshPermStateToKernel(const std::vector<std::str
         return RET_SUCCESS;
     }
 
-    Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::shared_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     auto iter = requestedPermData_.find(tokenId);
     if (iter == requestedPermData_.end()) {
         LOGE(ATM_DOMAIN, ATM_TAG, "TokenID is not exist in requestedPermData_ %{public}u.", tokenId);
@@ -958,7 +958,7 @@ int32_t PermissionDataBrief::AddBriefPermData(AccessTokenID tokenID, const std::
     std::map<std::string, std::string> aclExtendedMap;
     aclExtendedMap[permissionName] = value;
 
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permissionStateDataLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permissionStateDataLock_);
     BriefPermData data;
     if (!GetPermissionBriefData(tokenID, status, aclExtendedMap, data)) {
         return AccessTokenError::ERR_PERMISSION_NOT_EXIST;
diff --git a/services/accesstokenmanager/main/cpp/src/permission/permission_manager.cpp b/services/accesstokenmanager/main/cpp/src/permission/permission_manager.cpp
index 1f3afa3e8e616b2c640cdf357692a2bee61f22e9..37ccb7cc2ae272e4b9fa0b5b55708b0e637bf1ad 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/permission_manager.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/permission_manager.cpp
@@ -345,7 +345,7 @@ int32_t PermissionManager::RequestAppPermOnSetting(const HapTokenInfo& hapInfo,
 
 void PermissionManager::ParamUpdate(const std::string& permissionName, uint32_t flag, bool filtered)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permParamSetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permParamSetLock_);
     if (filtered || (IsOperablePermission(permissionName) &&
         ((flag != PERMISSION_PRE_AUTHORIZED_CANCELABLE) && (flag != PERMISSION_SYSTEM_FIXED)))) {
         paramValue_++;
@@ -360,7 +360,7 @@ void PermissionManager::ParamUpdate(const std::string& permissionName, uint32_t
 
 void PermissionManager::ParamFlagUpdate()
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->permFlagParamSetLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->permFlagParamSetLock_);
     paramFlagValue_++;
     LOGD(ATM_DOMAIN, ATM_TAG,
         "paramFlagValue_ change %{public}llu", static_cast<unsigned long long>(paramFlagValue_));
diff --git a/services/accesstokenmanager/main/cpp/src/permission/token_modify_notifier.cpp b/services/accesstokenmanager/main/cpp/src/permission/token_modify_notifier.cpp
index ac7206df273047dc46665ce909304aba2031ebda..61c240d596fa5a30d28331553d3f8971d9fb7fa3 100644
--- a/services/accesstokenmanager/main/cpp/src/permission/token_modify_notifier.cpp
+++ b/services/accesstokenmanager/main/cpp/src/permission/token_modify_notifier.cpp
@@ -49,7 +49,7 @@ void TokenModifyNotifier::AddHapTokenObservation(AccessTokenID tokenID)
         LOGI(ATM_DOMAIN, ATM_TAG, "Observation token is not hap token");
         return;
     }
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->listLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->listLock_);
     if (observationSet_.count(tokenID) <= 0) {
         observationSet_.insert(tokenID);
     }
@@ -57,7 +57,7 @@ void TokenModifyNotifier::AddHapTokenObservation(AccessTokenID tokenID)
 
 void TokenModifyNotifier::NotifyTokenDelete(AccessTokenID tokenID)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->listLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->listLock_);
     if (observationSet_.count(tokenID) <= 0) {
         LOGD(ATM_DOMAIN, ATM_TAG, "Hap token is not observed");
         return;
@@ -69,7 +69,7 @@ void TokenModifyNotifier::NotifyTokenDelete(AccessTokenID tokenID)
 
 void TokenModifyNotifier::NotifyTokenModify(AccessTokenID tokenID)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->listLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->listLock_);
     if (observationSet_.count(tokenID) <= 0) {
         LOGD(ATM_DOMAIN, ATM_TAG, "Hap token is not observed");
         return;
@@ -90,7 +90,7 @@ TokenModifyNotifier& TokenModifyNotifier::GetInstance()
     }
 
     if (!instance->hasInited_) {
-        Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(instance->initLock_);
+        std::unique_lock<std::shared_mutex> infoGuard(instance->initLock_);
         if (!instance->hasInited_) {
             instance->notifyTokenWorker_.Start(1);
             instance->hasInited_ = true;
@@ -104,7 +104,7 @@ void TokenModifyNotifier::NotifyTokenSyncTask()
 {
     LOGI(ATM_DOMAIN, ATM_TAG, "Called!");
 
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->notifyLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->notifyLock_);
     LOGI(ATM_DOMAIN, ATM_TAG, "Start execution!");
     LibraryLoader loader(TOKEN_SYNC_LIBPATH);
     TokenSyncKitInterface* tokenSyncKit = loader.GetObject<TokenSyncKitInterface>();
@@ -116,7 +116,7 @@ void TokenModifyNotifier::NotifyTokenSyncTask()
     std::vector<AccessTokenID> deleteList;
     std::vector<AccessTokenID> modifiedList;
     {
-        Utils::UniqueWriteGuard<Utils::RWLock> listGuard(this->listLock_);
+        std::unique_lock<std::shared_mutex> listGuard(this->listLock_);
         deleteList = deleteTokenList_;
         modifiedList = modifiedTokenList_;
         deleteTokenList_.clear();
@@ -156,7 +156,7 @@ void TokenModifyNotifier::NotifyTokenSyncTask()
 int32_t TokenModifyNotifier::GetRemoteHapTokenInfo(const std::string& deviceID, AccessTokenID tokenID)
 {
     if (tokenSyncCallbackObject_ != nullptr) {
-        Utils::UniqueReadGuard<Utils::RWLock> infoGuard(this->notifyLock_);
+        std::shared_lock<std::shared_mutex> infoGuard(this->notifyLock_);
         int32_t ret = tokenSyncCallbackObject_->GetRemoteHapTokenInfo(deviceID, tokenID);
         if (ret != TOKEN_SYNC_OPENSOURCE_DEVICE) {
             return ret;
@@ -174,7 +174,7 @@ int32_t TokenModifyNotifier::GetRemoteHapTokenInfo(const std::string& deviceID,
 
 int32_t TokenModifyNotifier::RegisterTokenSyncCallback(const sptr<IRemoteObject>& callback)
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->notifyLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->notifyLock_);
     tokenSyncCallbackObject_ = new TokenSyncCallbackProxy(callback);
     tokenSyncCallbackDeathRecipient_ = sptr<TokenSyncCallbackDeathRecipient>::MakeSptr();
     callback->AddDeathRecipient(tokenSyncCallbackDeathRecipient_);
@@ -184,7 +184,7 @@ int32_t TokenModifyNotifier::RegisterTokenSyncCallback(const sptr<IRemoteObject>
 
 void TokenModifyNotifier::UnRegisterTokenSyncCallback()
 {
-    Utils::UniqueWriteGuard<Utils::RWLock> infoGuard(this->notifyLock_);
+    std::unique_lock<std::shared_mutex> infoGuard(this->notifyLock_);
     if (tokenSyncCallbackObject_ != nullptr && tokenSyncCallbackDeathRecipient_ != nullptr) {
         tokenSyncCallbackObject_->AsObject()->RemoveDeathRecipient(tokenSyncCallbackDeathRecipient_);
     }