diff --git a/libpurgeablemem/cpp/include/purgeable_resource_manager.h b/libpurgeablemem/cpp/include/purgeable_resource_manager.h
index 9407ff1db7add8b1b5ed4c71f5e5314156c7b4bb..c84aab13653b45e63514f526d1c7553a63fb56f6 100644
--- a/libpurgeablemem/cpp/include/purgeable_resource_manager.h
+++ b/libpurgeablemem/cpp/include/purgeable_resource_manager.h
@@ -29,11 +29,12 @@ namespace PurgeableMem {
 /* System parameter name */
 const std::string THREAD_POOL_TASK_NUMBER_SYS_NAME = "persist.commonlibrary.purgeable.threadpooltasknum";
 const std::string LRU_CACHE_CAPACITY_SYS_NAME = "persist.commonlibrary.purgeable.lrucachecapacity";
+const std::string THREAD_POOL_NAME = "PurgeThread";
 /* Threadpool task number and lrucache capacity */
 constexpr int32_t THREAD_POOL_TASK_NUMBER = 4;
 constexpr int32_t MIN_THREAD_POOL_TASK_NUMBER = 1;
 constexpr int32_t MAX_THREAD_POOL_TASK_NUMBER = 20;
-constexpr int32_t LRU_CACHE_CAPACITY = 500;
+constexpr int32_t LRU_CACHE_CAPACITY = 200;
 constexpr int32_t MIN_LRU_CACHE_CAPACITY = 1;
 constexpr int32_t MAX_LRU_CACHE_CAPACITY = 2000;
 
@@ -98,13 +99,14 @@ public:
 
 private:
     PurgeableResourceManager();
-    int32_t GetThreadPoolTaskNumFromSysPara();
-    int32_t GetLruCacheCapacityFromSysPara();
-    void GetParaFromConfiguration();
+    int32_t GetThreadPoolTaskNumFromSysPara() const;
+    int32_t GetLruCacheCapacityFromSysPara() const;
+    void StartThreadPool();
 
     mutable std::mutex mutex_;
     LruCache lruCache_;
-    ThreadPool threadPool_;
+    ThreadPool threadPool_ {THREAD_POOL_NAME};
+    bool isThreadPoolStarted_ {false};
 };
 } /* namespace PurgeableMem */
 } /* namespace OHOS */
diff --git a/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp b/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp
index 04dbbd132ad70fc49ae448b2160270d2c6199225..4790342d8f9551867d7863dade7994ae4eeb39a8 100644
--- a/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp
+++ b/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp
@@ -119,13 +119,22 @@ size_t LruCache::Size() const
 
 PurgeableResourceManager::PurgeableResourceManager()
 {
-    GetParaFromConfiguration();
+    int32_t lruCacheCapacity = GetLruCacheCapacityFromSysPara();
+    if (lruCacheCapacity < MIN_LRU_CACHE_CAPACITY || lruCacheCapacity > MAX_LRU_CACHE_CAPACITY) {
+        PM_HILOG_ERROR(LOG_CORE, "[PurgeableResourceManager] Get error lrucache capacity from system parameter.");
+        lruCacheCapacity = LRU_CACHE_CAPACITY;
+    }
+    lruCache_.SetCapacity(lruCacheCapacity);
+    isThreadPoolStarted_ = false;
+    PM_HILOG_DEBUG(LOG_CORE, "PurgeableResourceManager init. lruCacheCapacity is: %{public}d", lruCacheCapacity);
 }
 
 PurgeableResourceManager::~PurgeableResourceManager()
 {
     std::lock_guard<std::mutex> lock(mutex_);
-    threadPool_.Stop();
+    if (isThreadPoolStarted_) {
+        threadPool_.Stop();
+    }
     lruCache_.Clear();
 }
 
@@ -140,11 +149,19 @@ void PurgeableResourceManager::BeginAccessPurgeableMem()
     std::lock_guard<std::mutex> lock(mutex_);
     StartTrace(HITRACE_TAG_COMMONLIBRARY, "OHOS::PurgeableMem::PurgeableResourceManager::BeginAccessPurgeableMem");
     std::list<std::shared_ptr<PurgeableMemBase>> resourcePtrList = lruCache_.GetResourcePtrList();
+
+    if (resourcePtrList.size() == 0) {
+        return;
+    }
+
+    if (!isThreadPoolStarted_) {
+        StartThreadPool();
+    }
+
     for (auto &resourcePtr : resourcePtrList) {
         if (resourcePtr == nullptr) {
             continue;
         }
-
         auto task = std::bind(&PurgeableMemBase::BeginReadWithDataLock, resourcePtr);
         threadPool_.AddTask(task);
     }
@@ -159,11 +176,19 @@ void PurgeableResourceManager::EndAccessPurgeableMem()
     std::lock_guard<std::mutex> lock(mutex_);
     StartTrace(HITRACE_TAG_COMMONLIBRARY, "OHOS::PurgeableMem::PurgeableResourceManager::EndAccessPurgeableMem");
     std::list<std::shared_ptr<PurgeableMemBase>> resourcePtrList = lruCache_.GetResourcePtrList();
+
+    if (resourcePtrList.size() == 0) {
+        return;
+    }
+
+    if (!isThreadPoolStarted_) {
+        StartThreadPool();
+    }
+
     for (auto &resourcePtr : resourcePtrList) {
         if (resourcePtr == nullptr) {
             continue;
         }
-
         auto task = std::bind(&PurgeableMemBase::EndReadWithDataLock, resourcePtr);
         threadPool_.AddTask(task);
     }
@@ -258,37 +283,31 @@ void PurgeableResourceManager::ShowLruCache() const
     }
 }
 
-int32_t PurgeableResourceManager::GetThreadPoolTaskNumFromSysPara()
+int32_t PurgeableResourceManager::GetThreadPoolTaskNumFromSysPara() const
 {
     return system::GetIntParameter<int32_t>(THREAD_POOL_TASK_NUMBER_SYS_NAME, THREAD_POOL_TASK_NUMBER);
 }
 
-int32_t PurgeableResourceManager::GetLruCacheCapacityFromSysPara()
+int32_t PurgeableResourceManager::GetLruCacheCapacityFromSysPara() const
 {
     return system::GetIntParameter<int32_t>(LRU_CACHE_CAPACITY_SYS_NAME, LRU_CACHE_CAPACITY);
 }
 
-void PurgeableResourceManager::GetParaFromConfiguration()
+void PurgeableResourceManager::StartThreadPool()
 {
-    int32_t threadPoolTaskNum = GetThreadPoolTaskNumFromSysPara();
-    int32_t lruCacheCapacity = GetLruCacheCapacityFromSysPara();
-    if (threadPoolTaskNum < MIN_THREAD_POOL_TASK_NUMBER || threadPoolTaskNum > MAX_THREAD_POOL_TASK_NUMBER) {
-        PM_HILOG_ERROR(LOG_CORE, "[PurgeableResourceManager] Get error threadpool task number from system parameter.");
-        return;
-    }
-
-    if (lruCacheCapacity < MIN_LRU_CACHE_CAPACITY || lruCacheCapacity > MAX_LRU_CACHE_CAPACITY) {
-        PM_HILOG_ERROR(LOG_CORE, "[PurgeableResourceManager] Get error lrucache capacity from system parameter.");
+    if (isThreadPoolStarted_) {
         return;
     }
 
-    lruCache_.SetCapacity(lruCacheCapacity);
-    if (threadPool_.GetThreadsNum() == 0) {
-        threadPool_.Start(threadPoolTaskNum);
+    int32_t threadPoolTaskNum = GetThreadPoolTaskNumFromSysPara();
+    if (threadPoolTaskNum < MIN_THREAD_POOL_TASK_NUMBER || threadPoolTaskNum > MAX_THREAD_POOL_TASK_NUMBER) {
+        PM_HILOG_ERROR(LOG_CORE, "[PurgeableResourceManager] Get error threadpool task number from system parameter.");
+        threadPoolTaskNum = THREAD_POOL_TASK_NUMBER;
     }
 
-    PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] lruCacheCapacity is: %{public}d, "
-        "threadPool threadsNum is: %{public}zu", lruCacheCapacity, threadPool_.GetThreadsNum());
+    threadPool_.Start(threadPoolTaskNum);
+    isThreadPoolStarted_ = true;
+    PM_HILOG_DEBUG(LOG_CORE, "StartThreadPool finish.");
 }
 } /* namespace PurgeableMem */
 } /* namespace OHOS */
\ No newline at end of file