diff --git a/common/include/dm_constants.h b/common/include/dm_constants.h
index 36e9771885887d27a6809b0acb7c1e7fdd06a73c..91877cd1970aa5a60e5f383066c196b9057dfaeb 100755
--- a/common/include/dm_constants.h
+++ b/common/include/dm_constants.h
@@ -183,7 +183,7 @@ enum ScreenState {
 // errCode map
 DM_EXPORT extern const std::map<int32_t, int32_t> MAP_ERROR_CODE;
 // wise device
-DM_EXPORT extern const int32_t MAX_CONTAINER_SIZE;
+DM_EXPORT extern const uint32_t MAX_CONTAINER_SIZE;
 DM_EXPORT extern const int32_t MAX_DEVICE_PROFILE_SIZE;
 const int32_t DEVICE_NAME_MAX_BYTES = 100;
 
diff --git a/common/include/dm_log.h b/common/include/dm_log.h
index fffad3bf4b356abbd7afe29454874feeabc583f4..70f16b9eec1b4798dd140512b3188bf091718344 100644
--- a/common/include/dm_log.h
+++ b/common/include/dm_log.h
@@ -51,6 +51,22 @@ namespace DistributedHardware {
             return (ret);                       \
         }                                       \
     } while (0)
+
+#define CHECK_SIZE_VOID(container)                    \
+    do {                                        \
+        if ((container).size() >= MAX_CONTAINER_SIZE) {                 \
+            LOGE("container size is more than max size");    \
+            return;                             \
+        }                                       \
+    } while (0)
+
+#define CHECK_SIZE_RETURN(container, ret)             \
+    do {                                        \
+        if ((container).size() >= MAX_CONTAINER_SIZE) {                 \
+            LOGE("container size is more than max size");    \
+            return (ret);                       \
+        }                                       \
+    } while (0)
 } // namespace DistributedHardware
 } // namespace OHOS
 #endif // OHOS_DM_LOG_H
diff --git a/common/src/dfx/standard/dm_hidumper.cpp b/common/src/dfx/standard/dm_hidumper.cpp
index 62f18202dd52bae66c1831ce5dbc0ec6d3650ec7..faa0b4161600fbf2ed8f0cd4021ff751b607c4d5 100644
--- a/common/src/dfx/standard/dm_hidumper.cpp
+++ b/common/src/dfx/standard/dm_hidumper.cpp
@@ -70,10 +70,7 @@ int32_t HiDumpHelper::HiDump(const std::vector<std::string>& args, std::string &
 void HiDumpHelper::SetNodeInfo(const DmDeviceInfo& deviceInfo)
 {
     LOGI("HiDumpHelper::SetNodeInfo");
-    if (nodeInfos_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("nodeInfos_ size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(nodeInfos_);
     nodeInfos_.push_back(deviceInfo);
 }
 
diff --git a/common/src/dm_constants.cpp b/common/src/dm_constants.cpp
index cfcdbe8ef4bd72fa94869b5f840eaf0b50351a38..3be5b9fb7ff00724ac4a11f6ca59fa1d149cb39c 100644
--- a/common/src/dm_constants.cpp
+++ b/common/src/dm_constants.cpp
@@ -173,7 +173,7 @@ const std::map<int32_t, int32_t> MAP_ERROR_CODE = {
 };
 
 // wise device
-const int32_t MAX_CONTAINER_SIZE = 1000;
+const uint32_t MAX_CONTAINER_SIZE = 1000;
 const int32_t MAX_DEVICE_PROFILE_SIZE = 500;
 const char* ACL_IS_LNN_ACL_KEY = "IsLnnAcl";
 const char* ACL_IS_LNN_ACL_VAL_TRUE = "true";
diff --git a/commondependency/src/multiple_user_connector.cpp b/commondependency/src/multiple_user_connector.cpp
index 10f23128574966e428834e759e4dc5e51b93f592..ababf27706e32898b5aaaf6c292da2f9ff3842f9 100644
--- a/commondependency/src/multiple_user_connector.cpp
+++ b/commondependency/src/multiple_user_connector.cpp
@@ -209,10 +209,7 @@ DM_EXPORT void MultipleUserConnector::SetAccountInfo(int32_t userId,
     DMAccountInfo dmAccountInfo)
 {
     std::lock_guard<std::mutex> lock(dmAccountInfoMaplock_);
-    if (dmAccountInfoMap_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("dmAccountInfoMap_ size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(dmAccountInfoMap_);
     dmAccountInfoMap_[userId] = dmAccountInfo;
 }
 
diff --git a/interfaces/cj/kits/src/device_manager_impl.cpp b/interfaces/cj/kits/src/device_manager_impl.cpp
index 1c5e1582304fae79fc0fd5ff86ecbeaacb01f145..faffd17bf4f6f7c0f74037b5868ce39fd2481ae7 100644
--- a/interfaces/cj/kits/src/device_manager_impl.cpp
+++ b/interfaces/cj/kits/src/device_manager_impl.cpp
@@ -156,18 +156,12 @@ DeviceManagerFfiImpl::DeviceManagerFfiImpl(const std::string &bundleName, int32_
     }
     {
         std::lock_guard<std::mutex> autoLock(g_initCallbackMapMutex);
-        if (g_initCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_initCallbackMap map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(g_initCallbackMap);
         g_initCallbackMap[bundleName_] = initCallback;
     }
 
     std::lock_guard<std::mutex> autoLock(g_deviceManagerMapMutex);
-    if (g_deviceManagerMap.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("g_deviceManagerMap map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(g_deviceManagerMap);
     g_deviceManagerMap[bundleName_] = this;
 }
 
@@ -377,10 +371,7 @@ int32_t DeviceManagerFfiImpl::StartDiscovering(const std::string &extra)
         std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
         auto iter = g_DiscoveryCallbackMap.find(bundleName_);
         if (iter == g_DiscoveryCallbackMap.end()) {
-            if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_DiscoveryCallbackMap map size is more than max size");
-                return DM_ERR_FAILED;
-            }
+            CHECK_SIZE_RETURN(g_DiscoveryCallbackMap, DM_ERR_FAILED);
             discoveryCallback = std::make_shared<DmFfiDiscoveryCallback>(bundleName_);
             g_DiscoveryCallbackMap[bundleName_] = discoveryCallback;
         } else {
@@ -420,11 +411,8 @@ int32_t DeviceManagerFfiImpl::BindDevice(const std::string &deviceId, const std:
         std::lock_guard<std::mutex> autoLock(g_authCallbackMapMutex);
         auto iter = g_authCallbackMap.find(bundleName_);
         if (iter == g_authCallbackMap.end()) {
+            CHECK_SIZE_RETURN(g_authCallbackMap, DM_ERR_FAILED);
             bindDeviceCallback = std::make_shared<DmFfiAuthenticateCallback>(bundleName_);
-            if (g_authCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_authCallbackMap map size is more than max size");
-                return DM_ERR_FAILED;
-            }
             g_authCallbackMap[bundleName_] = bindDeviceCallback;
         } else {
             bindDeviceCallback = iter->second;
@@ -458,10 +446,8 @@ int32_t DeviceManagerFfiImpl::BindTarget(const std::string &deviceId,
         {
             std::lock_guard<std::mutex> autoLock(g_bindCallbackMapMutex);
             auto iter = g_bindCallbackMap.find(bundleName_);
-            if (iter == g_bindCallbackMap.end() && g_bindCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_bindCallbackMap map size is more than max size");
-                return DM_ERR_FAILED;
-            } else if (iter == g_bindCallbackMap.end() && g_bindCallbackMap.size() < MAX_CONTAINER_SIZE) {
+            if (iter == g_bindCallbackMap.end()) {
+                CHECK_SIZE_RETURN(g_bindCallbackMap, DM_ERR_FAILED);
                 bindTargetCallback = std::make_shared<DmFfiBindTargetCallback>(bundleName_);
                 g_bindCallbackMap[bundleName_] = bindTargetCallback;
             } else {
@@ -744,10 +730,7 @@ int32_t DeviceManagerFfiImpl::RegisterDevStatusCallback()
     }
     {
         std::lock_guard<std::mutex> autoLock(g_deviceStatusCallbackMapMutex);
-        if (g_deviceStatusCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_deviceStatusCallbackMap map size is more than max size");
-            return DM_ERR_FAILED;
-        }
+        CHECK_SIZE_RETURN(g_deviceStatusCallbackMap, DM_ERR_FAILED);
         g_deviceStatusCallbackMap[bundleName_] = callback;
     }
     return ERR_OK;
@@ -758,10 +741,7 @@ int32_t DeviceManagerFfiImpl::RegisterDiscoveryCallback()
     auto discoveryCallback = std::make_shared<DmFfiDiscoveryCallback>(bundleName_);
     {
         std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
-        if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_DiscoveryCallbackMap map size is more than max size");
-            return DM_ERR_FAILED;
-        }
+        CHECK_SIZE_RETURN(g_DiscoveryCallbackMap, DM_ERR_FAILED);
         g_DiscoveryCallbackMap[bundleName_] = discoveryCallback;
     }
     discoveryCallback->IncreaseRefCount();
@@ -773,10 +753,7 @@ int32_t DeviceManagerFfiImpl::RegisterPublishCallback()
     auto publishCallback = std::make_shared<DmFfiPublishCallback>(bundleName_);
     {
         std::lock_guard<std::mutex> autoLock(g_publishCallbackMapMutex);
-        if (g_publishCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_publishCallbackMap map size is more than max size");
-            return DM_ERR_FAILED;
-        }
+        CHECK_SIZE_RETURN(g_publishCallbackMap, DM_ERR_FAILED);
         g_publishCallbackMap[bundleName_] = publishCallback;
     }
     publishCallback->IncreaseRefCount();
@@ -794,10 +771,7 @@ int32_t DeviceManagerFfiImpl::RegisterReplyCallback()
     }
     {
         std::lock_guard<std::mutex> autoLock(g_dmUiCallbackMapMutex);
-        if (g_dmUiCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_dmUiCallbackMap map size is more than max size");
-            return DM_ERR_FAILED;
-        }
+        CHECK_SIZE_RETURN(g_dmUiCallbackMap, DM_ERR_FAILED);
         g_dmUiCallbackMap[bundleName_] = dmUiCallback;
     }
     return ERR_OK;
diff --git a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
index 75fd0819c6a71d70cbe706462099c9b29bd67812..d07c6ff6860971db662beb87cfc9f1e12e74e489 100644
--- a/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
+++ b/interfaces/inner_kits/native_cpp/src/device_manager_impl.cpp
@@ -1986,17 +1986,13 @@ uint16_t DeviceManagerImpl::AddDiscoveryCallback(const std::string &pkgName,
         std::lock_guard<std::mutex> autoLock(subMapLock);
         auto item = pkgName2SubIdMap_.find(pkgNameTemp);
         if (item == pkgName2SubIdMap_.end() && subscribeId == DM_INVALID_FLAG_ID) {
-            if (pkgName2SubIdMap_.size() >= MAX_CONTAINER_SIZE || randSubIdSet_.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("pkgName2SubIdMap_ or randSubIdSet_ size is more than max size");
-                return DM_INVALID_FLAG_ID;
-            }
+            CHECK_SIZE_RETURN(pkgName2SubIdMap_, DM_INVALID_FLAG_ID);
+            CHECK_SIZE_RETURN(randSubIdSet_, DM_INVALID_FLAG_ID);
             subscribeId = GenUniqueRandUint(randSubIdSet_);
             pkgName2SubIdMap_[pkgNameTemp] = subscribeId;
         } else if (item == pkgName2SubIdMap_.end() && subscribeId != DM_INVALID_FLAG_ID) {
-            if (pkgName2SubIdMap_.size() >= MAX_CONTAINER_SIZE || randSubIdSet_.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("pkgName2SubIdMap_ or randSubIdSet_ size is more than max size");
-                return DM_INVALID_FLAG_ID;
-            }
+            CHECK_SIZE_RETURN(pkgName2SubIdMap_, DM_INVALID_FLAG_ID);
+            CHECK_SIZE_RETURN(randSubIdSet_, DM_INVALID_FLAG_ID);
             pkgName2SubIdMap_[pkgNameTemp] = subscribeId;
             randSubIdSet_.emplace(subscribeId);
         } else if (item != pkgName2SubIdMap_.end()) {
@@ -2034,10 +2030,8 @@ int32_t DeviceManagerImpl::AddPublishCallback(const std::string &pkgName)
         if (pkgName2PubIdMap_.find(pkgName) != pkgName2PubIdMap_.end()) {
             publishId = pkgName2PubIdMap_[pkgName];
         } else {
-            if (pkgName2PubIdMap_.size() >= MAX_CONTAINER_SIZE || randPubIdSet_.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("pkgName2PubIdMap_ or randPubIdSet_ is more than max size");
-                return DM_INVALID_FLAG_ID;
-            }
+            CHECK_SIZE_RETURN(pkgName2PubIdMap_, DM_INVALID_FLAG_ID);
+            CHECK_SIZE_RETURN(randPubIdSet_, DM_INVALID_FLAG_ID);
             publishId = GenUniqueRandUint(randPubIdSet_);
             pkgName2PubIdMap_[pkgName] = publishId;
         }
diff --git a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp
index f7731d2773c8d765e81bed59aab29173283df871..8c546e2f1920bb6661f440f2145d6e68111e16b5 100644
--- a/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp
+++ b/interfaces/inner_kits/native_cpp/src/ipc/lite/ipc_client_manager.cpp
@@ -37,11 +37,7 @@ int32_t IpcClientManager::Init(const std::string &pkgName)
         LOGE("ipcclientstub init failed.");
         return ERR_DM_INIT_FAILED;
     }
-    if (packageInitSet_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("packageInitSet_ size is more than max size");
-        return ERR_DM_FAILED;
-    }
-
+    CHECK_SIZE_RETURN(packageInitSet_, ERR_DM_FAILED);
     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
     req->SetPkgName(pkgName);
diff --git a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
index 93b2ef4fbdf31ee0d8153ce557ba65eb2dd2f63a..ca6d2307db5ed6524e5559d37086a1239ca3df56 100644
--- a/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
+++ b/interfaces/inner_kits/native_cpp/src/ipc/standard/ipc_client_manager.cpp
@@ -85,11 +85,7 @@ int32_t IpcClientManager::Init(const std::string &pkgName)
         LOGE("InitDeviceManager Failed with ret %{public}d", ret);
         return ret;
     }
-    if (dmListener_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("dmListener_ size is more than max size");
-        return ERR_DM_FAILED;
-    }
-
+    CHECK_SIZE_RETURN(dmListener_, ERR_DM_FAILED);
     sptr<IpcClientStub> listener = sptr<IpcClientStub>(new IpcClientStub());
     std::shared_ptr<IpcRegisterListenerReq> req = std::make_shared<IpcRegisterListenerReq>();
     std::shared_ptr<IpcRsp> rsp = std::make_shared<IpcRsp>();
diff --git a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp
index 9b4674a105d63a59919917739f5a7abf742a3807..907efd2984775652335f81fb84458d28406fce53 100644
--- a/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp
+++ b/interfaces/inner_kits/native_cpp/src/notify/device_manager_notify.cpp
@@ -46,10 +46,7 @@ void DeviceManagerNotify::RegisterDeathRecipientCallback(const std::string &pkgN
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (dmInitCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("dmInitCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(dmInitCallback_);
     dmInitCallback_[pkgName] = dmInitCallback;
 }
 
@@ -71,10 +68,7 @@ void DeviceManagerNotify::RegisterDeviceStateCallback(const std::string &pkgName
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (deviceStateCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceStateCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(deviceStateCallback_);
     deviceStateCallback_[pkgName] = callback;
 }
 
@@ -106,10 +100,7 @@ void DeviceManagerNotify::RegisterDeviceStatusCallback(const std::string &pkgNam
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (deviceStatusCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceStatusCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(deviceStatusCallback_);
     deviceStatusCallback_[pkgName] = callback;
 }
 
@@ -122,10 +113,7 @@ void DeviceManagerNotify::RegisterDiscoveryCallback(const std::string &pkgName,
     }
     std::lock_guard<std::mutex> autoLock(lock_);
     if (deviceDiscoveryCallbacks_.count(pkgName) == 0) {
-        if (deviceDiscoveryCallbacks_.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("deviceDiscoveryCallbacks_ map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(deviceDiscoveryCallbacks_);
         deviceDiscoveryCallbacks_[pkgName] = std::map<uint16_t, std::shared_ptr<DiscoveryCallback>>();
     }
     deviceDiscoveryCallbacks_[pkgName][subscribeId] = callback;
@@ -156,10 +144,7 @@ void DeviceManagerNotify::RegisterPublishCallback(const std::string &pkgName,
     }
     std::lock_guard<std::mutex> autoLock(lock_);
     if (devicePublishCallbacks_.count(pkgName) == 0) {
-        if (devicePublishCallbacks_.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("devicePublishCallbacks_ map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(devicePublishCallbacks_);
         devicePublishCallbacks_[pkgName] = std::map<int32_t, std::shared_ptr<PublishCallback>>();
     }
     devicePublishCallbacks_[pkgName][publishId] = callback;
@@ -190,10 +175,7 @@ void DeviceManagerNotify::RegisterAuthenticateCallback(const std::string &pkgNam
     }
     std::lock_guard<std::mutex> autoLock(lock_);
     if (authenticateCallback_.count(pkgName) == 0) {
-        if (authenticateCallback_.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("authenticateCallback_ map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(authenticateCallback_);
         authenticateCallback_[pkgName] = std::map<std::string, std::shared_ptr<AuthenticateCallback>>();
     }
     authenticateCallback_[pkgName][deviceId] = callback;
@@ -240,10 +222,7 @@ void DeviceManagerNotify::RegisterDeviceManagerFaCallback(const std::string &pkg
                                                           std::shared_ptr<DeviceManagerUiCallback> callback)
 {
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (dmUiCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("dmUiCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(dmUiCallback_);
     dmUiCallback_[pkgName] = callback;
 }
 
@@ -265,10 +244,7 @@ void DeviceManagerNotify::RegisterCredentialCallback(const std::string &pkgName,
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (credentialCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("credentialCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(credentialCallback_);
     credentialCallback_[pkgName] = callback;
 }
 
@@ -290,10 +266,7 @@ void DeviceManagerNotify::RegisterPinHolderCallback(const std::string &pkgName,
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (pinHolderCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("pinHolderCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(pinHolderCallback_);
     pinHolderCallback_[pkgName] = callback;
 }
 
@@ -745,10 +718,7 @@ void DeviceManagerNotify::RegisterBindCallback(const std::string &pkgName, const
     }
     std::lock_guard<std::mutex> autoLock(bindLock_);
     if (bindCallback_.count(pkgName) == 0) {
-        if (bindCallback_.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("bindCallback_ map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(bindCallback_);
         bindCallback_[pkgName] = std::map<PeerTargetId, std::shared_ptr<BindTargetCallback>>();
     }
     bindCallback_[pkgName][targetId] = callback;
@@ -764,10 +734,7 @@ void DeviceManagerNotify::RegisterUnbindCallback(const std::string &pkgName, con
     }
     std::lock_guard<std::mutex> autoLock(lock_);
     if (unbindCallback_.count(pkgName) == 0) {
-        if (unbindCallback_.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("unbindCallback_ map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(unbindCallback_);
         unbindCallback_[pkgName] = std::map<PeerTargetId, std::shared_ptr<UnbindTargetCallback>>();
     }
     unbindCallback_[pkgName][targetId] = callback;
@@ -1028,10 +995,7 @@ void DeviceManagerNotify::RegDevTrustChangeCallback(const std::string &pkgName,
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (devTrustChangeCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("devTrustChangeCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(devTrustChangeCallback_);
     devTrustChangeCallback_[pkgName] = callback;
 }
 
@@ -1089,10 +1053,7 @@ void DeviceManagerNotify::RegisterDeviceScreenStatusCallback(const std::string &
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (deviceScreenStatusCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceScreenStatusCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(deviceScreenStatusCallback_);
     deviceScreenStatusCallback_[pkgName] = callback;
 }
 
@@ -1137,10 +1098,7 @@ void DeviceManagerNotify::RegisterCredentialAuthStatusCallback(const std::string
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (credentialAuthStatusCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("credentialAuthStatusCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(credentialAuthStatusCallback_);
     credentialAuthStatusCallback_[pkgName] = callback;
 }
 
@@ -1186,10 +1144,7 @@ void DeviceManagerNotify::RegisterSinkBindCallback(const std::string &pkgName,
         return;
     }
     std::lock_guard<std::mutex> autoLock(lock_);
-    if (sinkBindTargetCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("sinkBindTargetCallback_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(sinkBindTargetCallback_);
     sinkBindTargetCallback_[pkgName] = callback;
 }
 
@@ -1299,10 +1254,7 @@ int32_t DeviceManagerNotify::RegisterGetDeviceProfileInfoListCallback(const std:
         return ERR_DM_CALLBACK_REGISTER_FAILED;
     }
     std::lock_guard<std::mutex> autoLock(bindLock_);
-    if (getDeviceProfileInfoCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(getDeviceProfileInfoCallback_, ERR_DM_CALLBACK_REGISTER_FAILED);
     getDeviceProfileInfoCallback_[pkgName] = callback;
     return DM_OK;
 }
@@ -1341,23 +1293,14 @@ int32_t DeviceManagerNotify::RegisterGetDeviceIconInfoCallback(const std::string
         return ERR_DM_CALLBACK_REGISTER_FAILED;
     }
     std::lock_guard<std::mutex> autoLock(bindLock_);
-    if (getDeviceIconInfoCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(getDeviceIconInfoCallback_, ERR_DM_CALLBACK_REGISTER_FAILED);
     auto iter = getDeviceIconInfoCallback_.find(pkgName);
     if (iter == getDeviceIconInfoCallback_.end()) {
         getDeviceIconInfoCallback_[pkgName][uk] = {callback};
         return DM_OK;
     }
-    if (iter->second.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map for pkg size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
-    if (iter->second[uk].size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback set size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(iter->second, ERR_DM_CALLBACK_REGISTER_FAILED);
+    CHECK_SIZE_RETURN(iter->second[uk], ERR_DM_CALLBACK_REGISTER_FAILED);
     iter->second[uk].insert(callback);
     return DM_OK;
 }
@@ -1411,10 +1354,7 @@ int32_t DeviceManagerNotify::RegisterSetLocalDeviceNameCallback(const std::strin
         return ERR_DM_CALLBACK_REGISTER_FAILED;
     }
     std::lock_guard<std::mutex> autoLock(bindLock_);
-    if (setLocalDeviceNameCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(setLocalDeviceNameCallback_, ERR_DM_CALLBACK_REGISTER_FAILED);
     setLocalDeviceNameCallback_[pkgName] = callback;
     return DM_OK;
 }
@@ -1428,19 +1368,13 @@ int32_t DeviceManagerNotify::RegisterSetRemoteDeviceNameCallback(const std::stri
         return ERR_DM_CALLBACK_REGISTER_FAILED;
     }
     std::lock_guard<std::mutex> autoLock(bindLock_);
-    if (setRemoteDeviceNameCallback_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(setRemoteDeviceNameCallback_, ERR_DM_CALLBACK_REGISTER_FAILED);
     auto iter = setRemoteDeviceNameCallback_.find(pkgName);
     if (iter == setRemoteDeviceNameCallback_.end()) {
         setRemoteDeviceNameCallback_[pkgName][deviceId] = callback;
         return DM_OK;
     }
-    if (iter->second.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("callback map size is more than max size");
-        return ERR_DM_CALLBACK_REGISTER_FAILED;
-    }
+    CHECK_SIZE_RETURN(iter->second, ERR_DM_CALLBACK_REGISTER_FAILED);
     iter->second[deviceId] = callback;
     return DM_OK;
 }
diff --git a/interfaces/kits/js/src/native_devicemanager_js.cpp b/interfaces/kits/js/src/native_devicemanager_js.cpp
index bddc9c805bd1fdce0354964322405d2039d67ed3..f7a1825bd8bb91fffeca56ce41c040227110bbd1 100644
--- a/interfaces/kits/js/src/native_devicemanager_js.cpp
+++ b/interfaces/kits/js/src/native_devicemanager_js.cpp
@@ -1346,10 +1346,7 @@ void DeviceManagerNapi::RegisterDevStateCallback(napi_env env, std::string &bund
     }
     {
         std::lock_guard<std::mutex> autoLock(g_deviceStateCallbackMapMutex);
-        if (g_deviceStateCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_deviceStateCallbackMap map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(g_deviceStateCallbackMap);
         g_deviceStateCallbackMap[bundleName] = callback;
     }
     return;
@@ -1367,10 +1364,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         auto callback = std::make_shared<DmNapiDiscoveryCallback>(env, bundleName);
         {
             std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
-            if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_DiscoveryCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_DiscoveryCallbackMap);
             g_DiscoveryCallbackMap[bundleName] = callback;
         }
         std::shared_ptr<DmNapiDiscoveryCallback> discoveryCallback = callback;
@@ -1382,10 +1376,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         auto callback = std::make_shared<DmNapiPublishCallback>(env, bundleName);
         {
             std::lock_guard<std::mutex> autoLock(g_publishCallbackMapMutex);
-            if (g_publishCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_publishCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_publishCallbackMap);
             g_publishCallbackMap[bundleName] = callback;
         }
         std::shared_ptr<DmNapiPublishCallback> publishCallback = callback;
@@ -1401,10 +1392,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         }
         {
             std::lock_guard<std::mutex> autoLock(g_dmUiCallbackMapMutex);
-            if (g_dmUiCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_dmUiCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_dmUiCallbackMap);
             g_dmUiCallbackMap[bundleName] = callback;
         }
     }
@@ -1424,10 +1412,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         }
         {
             std::lock_guard<std::mutex> autoLock(g_deviceStateCallbackMapMutex);
-            if (g_deviceStateCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_deviceStateCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_deviceStateCallbackMap);
             g_deviceStateCallbackMap[bundleName] = callback;
         }
     }
@@ -2300,11 +2285,8 @@ void DeviceManagerNapi::LockDiscoveryCallbackMutex(napi_env env, DmSubscribeInfo
         std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
         auto iter = g_DiscoveryCallbackMap.find(bundleName);
         if (iter == g_DiscoveryCallbackMap.end()) {
+            CHECK_SIZE_VOID(g_DiscoveryCallbackMap);
             discoveryCallback = std::make_shared<DmNapiDiscoveryCallback>(env, bundleName);
-            if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_DiscoveryCallbackMap map size is more than max size");
-                return;
-            }
             g_DiscoveryCallbackMap[bundleName] = discoveryCallback;
         } else {
             discoveryCallback = iter->second;
@@ -2428,11 +2410,8 @@ napi_value DeviceManagerNapi::PublishDeviceDiscoverySync(napi_env env, napi_call
         std::lock_guard<std::mutex> autoLock(g_publishCallbackMapMutex);
         auto iter = g_publishCallbackMap.find(deviceManagerWrapper->bundleName_);
         if (iter == g_publishCallbackMap.end()) {
+            CHECK_SIZE_RETURN(g_publishCallbackMap, nullptr);
             publishCallback = std::make_shared<DmNapiPublishCallback>(env, deviceManagerWrapper->bundleName_);
-            if (g_publishCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_publishCallbackMap map size is more than max size");
-                return nullptr;
-            }
             g_publishCallbackMap[deviceManagerWrapper->bundleName_] = publishCallback;
         } else {
             publishCallback = iter->second;
@@ -2523,11 +2502,8 @@ napi_value DeviceManagerNapi::AuthenticateDevice(napi_env env, napi_callback_inf
         std::lock_guard<std::mutex> autoLock(g_authCallbackMapMutex);
         auto iter = g_authCallbackMap.find(deviceManagerWrapper->bundleName_);
         if (iter == g_authCallbackMap.end()) {
+            CHECK_SIZE_RETURN(g_authCallbackMap, nullptr);
             authCallback = std::make_shared<DmNapiAuthenticateCallback>(env, deviceManagerWrapper->bundleName_);
-            if (g_authCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_authCallbackMap map size is more than max size");
-                return nullptr;
-            }
             g_authCallbackMap[deviceManagerWrapper->bundleName_] = authCallback;
         } else {
             authCallback = iter->second;
@@ -2605,11 +2581,8 @@ int32_t DeviceManagerNapi::RegisterCredentialCallback(napi_env env, const std::s
         std::lock_guard<std::mutex> autoLock(creMapLocks_);
         auto iter = g_creCallbackMap.find(pkgName);
         if (iter == g_creCallbackMap.end()) {
+            CHECK_SIZE_RETURN(g_creCallbackMap, ERR_DM_FAILED);
             creCallback = std::make_shared<DmNapiCredentialCallback>(env, pkgName);
-            if (g_creCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_creCallbackMap map size is more than max size");
-                return ERR_DM_FAILED;
-            }
             g_creCallbackMap[pkgName] = creCallback;
         } else {
             creCallback = iter->second;
diff --git a/interfaces/kits/js4.0/src/native_devicemanager_js.cpp b/interfaces/kits/js4.0/src/native_devicemanager_js.cpp
index a7894642a3c4e584bb7caa9ebf37b488a53dc213..a33de825116e5f89824bcdd574e61fcfb8af4424 100644
--- a/interfaces/kits/js4.0/src/native_devicemanager_js.cpp
+++ b/interfaces/kits/js4.0/src/native_devicemanager_js.cpp
@@ -868,10 +868,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         auto callback = std::make_shared<DmNapiDiscoveryCallback>(env, bundleName);
         {
             std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
-            if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_DiscoveryCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_DiscoveryCallbackMap);
             g_DiscoveryCallbackMap[bundleName] = callback;
         }
         std::shared_ptr<DmNapiDiscoveryCallback> discoveryCallback = callback;
@@ -883,10 +880,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         auto callback = std::make_shared<DmNapiPublishCallback>(env, bundleName);
         {
             std::lock_guard<std::mutex> autoLock(g_publishCallbackMapMutex);
-            if (g_publishCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_publishCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_publishCallbackMap);
             g_publishCallbackMap[bundleName] = callback;
         }
         std::shared_ptr<DmNapiPublishCallback> publishCallback = callback;
@@ -902,10 +896,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         }
         {
             std::lock_guard<std::mutex> autoLock(g_dmUiCallbackMapMutex);
-            if (g_dmUiCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_dmUiCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_dmUiCallbackMap);
             g_dmUiCallbackMap[bundleName] = callback;
         }
     }
@@ -930,10 +921,7 @@ void DeviceManagerNapi::RegisterDevStatusCallback(napi_env env, std::string &bun
     }
     {
         std::lock_guard<std::mutex> autoLock(g_deviceStatusCallbackMapMutex);
-        if (g_deviceStatusCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_deviceStatusCallbackMap map size is more than max size");
-            return;
-        }
+        CHECK_SIZE_VOID(g_deviceStatusCallbackMap);
         g_deviceStatusCallbackMap[bundleName] = callback;
     }
     return;
@@ -953,10 +941,7 @@ void DeviceManagerNapi::CreateDmCallback(napi_env env, std::string &bundleName,
         }
         {
             std::lock_guard<std::mutex> autoLock(g_deviceStatusCallbackMapMutex);
-            if (g_deviceStatusCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_deviceStatusCallbackMap map size is more than max size");
-                return;
-            }
+            CHECK_SIZE_VOID(g_deviceStatusCallbackMap);
             g_deviceStatusCallbackMap[bundleName] = callback;
         }
     }
@@ -1595,11 +1580,8 @@ void DeviceManagerNapi::LockDiscoveryCallbackMutex(napi_env env, std::string &bu
         std::lock_guard<std::mutex> autoLock(g_discoveryCallbackMapMutex);
         auto iter = g_DiscoveryCallbackMap.find(bundleName);
         if (iter == g_DiscoveryCallbackMap.end()) {
+            CHECK_SIZE_VOID(g_DiscoveryCallbackMap);
             discoveryCallback = std::make_shared<DmNapiDiscoveryCallback>(env, bundleName);
-            if (g_DiscoveryCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_DiscoveryCallbackMap map size is more than max size");
-                return;
-            }
             g_DiscoveryCallbackMap[bundleName] = discoveryCallback;
         } else {
             discoveryCallback = iter->second;
@@ -1714,10 +1696,8 @@ napi_value DeviceManagerNapi::PublishDeviceDiscoverySync(napi_env env, napi_call
     {
         std::lock_guard<std::mutex> autoLock(g_publishCallbackMapMutex);
         auto iter = g_publishCallbackMap.find(deviceManagerWrapper->bundleName_);
-        if (iter == g_publishCallbackMap.end() && g_publishCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_publishCallbackMap map size is more than max size");
-            return nullptr;
-        } else if (iter == g_publishCallbackMap.end() && g_publishCallbackMap.size() < MAX_CONTAINER_SIZE) {
+        if (iter == g_publishCallbackMap.end()) {
+            CHECK_SIZE_RETURN(g_publishCallbackMap, nullptr);
             publishCallback = std::make_shared<DmNapiPublishCallback>(env, deviceManagerWrapper->bundleName_);
             g_publishCallbackMap[deviceManagerWrapper->bundleName_] = publishCallback;
         } else {
@@ -1792,10 +1772,8 @@ void DeviceManagerNapi::BindDevOrTarget(DeviceManagerNapi *deviceManagerWrapper,
         {
             std::lock_guard<std::mutex> autoLock(g_bindCallbackMapMutex);
             auto iter = g_bindCallbackMap.find(deviceManagerWrapper->bundleName_);
-            if (iter == g_bindCallbackMap.end() && g_bindCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_bindCallbackMap map size is more than max size");
-                return;
-            } else if (iter == g_bindCallbackMap.end() && g_bindCallbackMap.size() < MAX_CONTAINER_SIZE) {
+            if (iter == g_bindCallbackMap.end()) {
+                CHECK_SIZE_VOID(g_bindCallbackMap);
                 bindTargetCallback = std::make_shared<DmNapiBindTargetCallback>(env, deviceManagerWrapper->bundleName_);
                 g_bindCallbackMap[deviceManagerWrapper->bundleName_] = bindTargetCallback;
             } else {
@@ -1815,11 +1793,8 @@ void DeviceManagerNapi::BindDevOrTarget(DeviceManagerNapi *deviceManagerWrapper,
         std::lock_guard<std::mutex> autoLock(g_authCallbackMapMutex);
         auto iter = g_authCallbackMap.find(deviceManagerWrapper->bundleName_);
         if (iter == g_authCallbackMap.end()) {
+            CHECK_SIZE_VOID(g_authCallbackMap);
             bindDeviceCallback = std::make_shared<DmNapiAuthenticateCallback>(env, deviceManagerWrapper->bundleName_);
-            if (g_authCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-                LOGE("g_authCallbackMap map size is more than max size");
-                return;
-            }
             g_authCallbackMap[deviceManagerWrapper->bundleName_] = bindDeviceCallback;
         } else {
             bindDeviceCallback = iter->second;
@@ -2813,10 +2788,7 @@ napi_value DeviceManagerNapi::CreateDeviceManager(napi_env env, napi_callback_in
     }
     {
         std::lock_guard<std::mutex> autoLock(g_initCallbackMapMutex);
-        if (g_initCallbackMap.size() >= MAX_CONTAINER_SIZE) {
-            LOGE("g_initCallbackMap map size is more than max size");
-            return nullptr;
-        }
+        CHECK_SIZE_RETURN(g_initCallbackMap, nullptr);
         g_initCallbackMap[bundleName] = initCallback;
     }
     napi_value ctor = nullptr;
diff --git a/services/softbuscache/src/dm_softbus_cache.cpp b/services/softbuscache/src/dm_softbus_cache.cpp
index fb537cda21de9764a70ad94e4a9e71b11a5f9750..b63fc79e3fe8f531a66c3a63373a05aea3bf19f0 100644
--- a/services/softbuscache/src/dm_softbus_cache.cpp
+++ b/services/softbuscache/src/dm_softbus_cache.cpp
@@ -143,10 +143,7 @@ void SoftbusCache::SaveDeviceInfo(DmDeviceInfo deviceInfo)
         return;
     }
     std::lock_guard<std::mutex> mutexLock(deviceInfosMutex_);
-    if (deviceInfo_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceInfo_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(deviceInfo_);
     deviceInfo_[udid] = std::pair<std::string, DmDeviceInfo>(uuid, deviceInfo);
     LOGI("success udid %{public}s, networkId %{public}s",
         GetAnonyString(udid).c_str(), GetAnonyString(std::string(deviceInfo.networkId)).c_str());
@@ -305,10 +302,7 @@ void SoftbusCache::SaveDeviceSecurityLevel(const char *networkId)
     if (deviceSecurityLevel_.find(std::string(networkId)) != deviceSecurityLevel_.end()) {
         return;
     }
-    if (deviceSecurityLevel_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceSecurityLevel_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(deviceSecurityLevel_);
     int32_t tempSecurityLevel = -1;
     if (GetNodeKeyInfo(DM_PKG_NAME, networkId, NodeDeviceInfoKey::NODE_KEY_DEVICE_SECURITY_LEVEL,
         reinterpret_cast<uint8_t *>(&tempSecurityLevel), LNN_COMMON_LEN) != DM_OK) {
@@ -354,10 +348,7 @@ int32_t SoftbusCache::GetDevLevelFromBus(const char *networkId, int32_t &securit
         LOGE("[SOFTBUS]GetNodeKeyInfo networkType failed.");
         return ERR_DM_FAILED;
     }
-    if (deviceSecurityLevel_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("deviceSecurityLevel_ map size is more than max size");
-        return ERR_DM_FAILED;
-    }
+    CHECK_SIZE_RETURN(deviceSecurityLevel_, ERR_DM_FAILED);
     securityLevel = tempSecurityLevel;
     deviceSecurityLevel_[std::string(networkId)] = tempSecurityLevel;
     LOGI("Get dev level from softbus success, networkId is %{public}s.",
diff --git a/utils/src/appInfo/standard/app_manager.cpp b/utils/src/appInfo/standard/app_manager.cpp
index 87cf4883ad0913577cfd3df46aaf03c86b806e91..e4d7b86b342b29af3e229a6d642997fe7e3156d0 100644
--- a/utils/src/appInfo/standard/app_manager.cpp
+++ b/utils/src/appInfo/standard/app_manager.cpp
@@ -33,7 +33,7 @@ using namespace OHOS::Security::AccessToken;
 namespace OHOS {
 namespace DistributedHardware {
 namespace {
-const int32_t MAX_CONTAINER_SIZE = 1000;
+const uint32_t MAX_CONTAINER_SIZE = 1000;
 }
 DM_IMPLEMENT_SINGLE_INSTANCE(AppManager);
 
@@ -86,10 +86,7 @@ DM_EXPORT void AppManager::RegisterCallerAppId(const std::string &pkgName)
     }
     LOGI("PkgName %{public}s, appId %{public}s.", pkgName.c_str(), GetAnonyString(appId).c_str());
     std::lock_guard<std::mutex> lock(appIdMapLock_);
-    if (appIdMap_.size() >= MAX_CONTAINER_SIZE) {
-        LOGE("appIdMap_ map size is more than max size");
-        return;
-    }
+    CHECK_SIZE_VOID(appIdMap_);
     appIdMap_[pkgName] = appId;
 }