diff --git a/services/core/include/persistenceadapter/kvadapter/kv_adapter.h b/services/core/include/persistenceadapter/kvadapter/kv_adapter.h
index c72296f56792fc626c39056b661525674e995ca4..c316595677e2309695e40027ebf30fd1b06c4b2b 100644
--- a/services/core/include/persistenceadapter/kvadapter/kv_adapter.h
+++ b/services/core/include/persistenceadapter/kvadapter/kv_adapter.h
@@ -16,7 +16,6 @@
 #ifndef OHOS_DP_KV_ADAPTER_H
 #define OHOS_DP_KV_ADAPTER_H
 
-#include <condition_variable>
 #include <map>
 #include <memory>
 #include <string>
@@ -68,7 +67,7 @@ private:
     int32_t UnRegisterDeathListener();
     int32_t DeleteDeathListener();
     int32_t SyncOnDemand(const std::string& udid, const std::string& keyPrefix,
-        std::map<std::string, std::string>& values);
+        std::vector<DistributedKv::Entry>& entries);
 
 private:
     DistributedKv::AppId appId_;
@@ -80,8 +79,6 @@ private:
     std::shared_ptr<DistributedKv::KvStoreSyncCallback> syncCompletedListener_ = nullptr;
     std::shared_ptr<DistributedKv::KvStoreDeathRecipient> deathRecipient_ = nullptr;
     std::mutex kvAdapterMutex_;
-    std::mutex syncOnDemandMtx_;
-    std::condition_variable syncOnDemandCond_;
     std::mutex syncOnDemandUdidSetMtx_;
     std::unordered_set<std::string> syncOnDemandUdidSet_;
 };
diff --git a/services/core/src/persistenceadapter/kvadapter/kv_adapter.cpp b/services/core/src/persistenceadapter/kvadapter/kv_adapter.cpp
index 6e6bcdaef56ffb4c0c71b7331c02865129d44fe6..178bd4836e3c5f002ca8d38b6884559b106e9d7f 100644
--- a/services/core/src/persistenceadapter/kvadapter/kv_adapter.cpp
+++ b/services/core/src/persistenceadapter/kvadapter/kv_adapter.cpp
@@ -15,6 +15,7 @@
 #include "kv_adapter.h"
 
 #include <cinttypes>
+#include <future>
 #include <mutex>
 
 #include "datetime_ex.h"
@@ -34,9 +35,7 @@ namespace {
     constexpr int32_t INIT_RETRY_SLEEP_INTERVAL = 200 * 1000; // 500ms
     const std::string DATABASE_DIR = "/data/service/el1/public/database/distributed_device_profile_service";
     const std::string TAG = "KVAdapter";
-    constexpr uint8_t ASYNC_GET_WAIT_SECONDS = 3;
-    constexpr bool ASYNC_GET_FINISHED = true;
-    constexpr bool ASYNC_GET_NO_FINISHED = false;
+    constexpr int32_t ASYNC_GET_WAIT_MS = 2000;
 }
 
 KVAdapter::KVAdapter(const std::string &appId, const std::string &storeId,
@@ -485,16 +484,31 @@ int32_t KVAdapter::GetByPrefix(const std::string& udid, const std::string& keyPr
         }
         syncOnDemandUdidSet_.insert(udid);
     }
-    int32_t ret = SyncOnDemand(udid, keyPrefix, values);
+    std::vector<DistributedKv::Entry> entries;
+    int32_t ret = SyncOnDemand(udid, keyPrefix, entries);
+    {
+        std::unique_lock<std::mutex> lck(syncOnDemandUdidSetMtx_);
+        syncOnDemandUdidSet_.erase(udid);
+    }
     if (ret != DP_SUCCESS) {
         HILOGE("SyncOnDemand fail, ret: %{public}d", ret);
         return ret;
     }
-    return GetByPrefix(keyPrefix, values);
+    if (!entries.empty()) {
+        for (const auto& item : entries) {
+            std::string dbKey = item.key.ToString();
+            std::string dbValue = item.value.ToString();
+            if (dbKey.find(udid) == std::string::npos) {
+                continue;
+            }
+            values[dbKey] = dbValue;
+        }
+    }
+    return DP_SUCCESS;
 }
 
 int32_t KVAdapter::SyncOnDemand(const std::string& udid, const std::string& keyPrefix,
-    std::map<std::string, std::string>& values)
+    std::vector<DistributedKv::Entry>& entries)
 {
     std::string networkId = "";
     if (ProfileCache::GetInstance().GetNetWorkIdByUdid(udid, networkId) != DP_SUCCESS) {
@@ -502,24 +516,16 @@ int32_t KVAdapter::SyncOnDemand(const std::string& udid, const std::string& keyP
         return DP_GET_NETWORKID_BY_UDID_FAIL;
     }
     HILOGI("networkId: %{public}s", ProfileUtils::GetAnonyString(networkId).c_str());
-    int32_t ret = DP_GET_KV_DB_FAIL;
-    bool isExeced = ASYNC_GET_NO_FINISHED;
-    auto call = [this, udid, &isExeced, &ret, &values] (DistributedKv::Status status,
+    std::promise<DistributedKv::Status> statusSignal;
+    auto storeId = storeId_.storeId;
+    auto call = [storeId, udid, &statusSignal, &entries] (DistributedKv::Status status,
         std::vector<DistributedKv::Entry>&& allEntries) {
         HILOGI("async GetEntries callback, storeId:%{public}s, udid:%{public}s, status:%{public}d, size:%{public}zu",
-            storeId_.storeId.c_str(), ProfileUtils::GetAnonyString(udid).c_str(), status, allEntries.size());
-        {
-            std::unique_lock<std::mutex> lck(syncOnDemandUdidSetMtx_);
-            syncOnDemandUdidSet_.erase(udid);
-        }
-        isExeced = ASYNC_GET_FINISHED;
+            storeId.c_str(), ProfileUtils::GetAnonyString(udid).c_str(), status, allEntries.size());
         if (status == DistributedKv::Status::SUCCESS) {
-            ret = DP_SUCCESS;
-        } else {
-            HILOGE("async GetEntries failed");
+            std::copy(allEntries.begin(), allEntries.end(), std::back_inserter(entries));
         }
-        std::unique_lock<std::mutex> lck(syncOnDemandMtx_);
-        syncOnDemandCond_.notify_one();
+        statusSignal.set_value(status);
     };
     DistributedKv::Key kvKeyPrefix(keyPrefix);
     {
@@ -532,9 +538,16 @@ int32_t KVAdapter::SyncOnDemand(const std::string& udid, const std::string& keyP
             storeId_.storeId.c_str(), ProfileUtils::GetAnonyString(udid).c_str());
         kvStorePtr_->GetEntries(kvKeyPrefix, networkId, call);
     }
-    std::unique_lock<std::mutex> lck(syncOnDemandMtx_);
-    syncOnDemandCond_.wait_for(lck, std::chrono::seconds(ASYNC_GET_WAIT_SECONDS), [& isExeced] {return isExeced;});
-    return ret;
+    DistributedKv::Status status = DistributedKv::Status::ERROR;
+    auto future = statusSignal.get_future();
+    if (future.wait_for(std::chrono::milliseconds(ASYNC_GET_WAIT_MS)) == std::future_status::ready) {
+        status = future.get();
+    }
+    if (status != DistributedKv::Status::SUCCESS) {
+        HILOGE("async GetEntries error: %{public}d", status);
+        return DP_GET_KV_DB_FAIL;
+    }
+    return DP_SUCCESS;
 }
 
 int32_t KVAdapter::Get(const std::string& udid, const std::string& key, std::string& value)
@@ -554,13 +567,28 @@ int32_t KVAdapter::Get(const std::string& udid, const std::string& key, std::str
         }
         syncOnDemandUdidSet_.insert(udid);
     }
-    std::map<std::string, std::string> values;
-    int32_t ret = SyncOnDemand(udid, key, values);
+    std::vector<DistributedKv::Entry> entries;
+    int32_t ret = SyncOnDemand(udid, key, entries);
+    {
+        std::unique_lock<std::mutex> lck(syncOnDemandUdidSetMtx_);
+        syncOnDemandUdidSet_.erase(udid);
+    }
     if (ret != DP_SUCCESS) {
         HILOGE("SyncOnDemand fail, ret: %{public}d", ret);
         return ret;
     }
-    return Get(key, value);
+    if (!entries.empty()) {
+        for (const auto& item : entries) {
+            std::string dbKey = item.key.ToString();
+            std::string dbValue = item.value.ToString();
+            if (dbKey.find(udid) == std::string::npos) {
+                continue;
+            }
+            value = dbValue;
+            break;
+        }
+    }
+    return DP_SUCCESS;
 }
 } // namespace DeviceProfile
 } // namespace OHOS