diff --git a/libpurgeablemem/cpp/include/purgeable_resource_manager.h b/libpurgeablemem/cpp/include/purgeable_resource_manager.h
index d9ae622563858a8c563061bd1633d63b0666f0d2..1f40ea767bc8a8899343927da8d28416f7bffd1b 100644
--- a/libpurgeablemem/cpp/include/purgeable_resource_manager.h
+++ b/libpurgeablemem/cpp/include/purgeable_resource_manager.h
@@ -21,8 +21,8 @@
 #include <string>
 #include <unordered_map>
 
-#include "thread_pool.h"
 #include "ffrt.h"
+
 namespace OHOS {
 namespace PurgeableMem {
 const std::string THREAD_POOL_NAME = "PurgeThread";
@@ -41,7 +41,6 @@ public:
     void RemoveResource(std::shared_ptr<PurgeableMemBase> resourcePtr);
     void SetRecentUsedResource(std::shared_ptr<PurgeableMemBase> resourcePtr);
     void SetLruCacheCapacity(int32_t capacity);
-    void AddTaskToThreadPool(const std::function<void()> &f);
     void Clear();
     void RemoveLastResource();
     void ShowLruCache() const;
@@ -50,7 +49,6 @@ private:
     PurgeableResourceManager();
     int32_t GetThreadPoolTaskNumFromSysPara() const;
     int32_t GetLruCacheCapacityFromSysPara() const;
-    void StartThreadPool();
     void ChangeDataValid(std::shared_ptr<PurgeableMemBase> resourcePtr, bool isVaild) const;
     void AddResourceInner(std::shared_ptr<PurgeableMemBase> resourcePtr);
     void RemoveResourceInner(std::shared_ptr<PurgeableMemBase> resourcePtr);
@@ -96,11 +94,8 @@ private:
         std::unordered_map<std::shared_ptr<PurgeableMemBase>, ListSharedPtrIterator> positionMap_;
     };
 
-    mutable std::mutex lruCacheMutex_;
-    mutable std::mutex threadPoolMutex_;
+    mutable ffrt::mutex lruCacheMutex_;
     LruCache lruCache_;
-    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 a962642bfdb870bb491fad6c16d5f51055802ef9..7e7dffb308f8d763a2c24c8c31db53a8b6453470 100644
--- a/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp
+++ b/libpurgeablemem/cpp/src/purgeable_resource_manager.cpp
@@ -23,13 +23,7 @@ namespace OHOS {
 namespace PurgeableMem {
 namespace {
 /* 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";
-
-/* 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 = 200;
 constexpr int32_t MIN_LRU_CACHE_CAPACITY = 1;
 constexpr int32_t MAX_LRU_CACHE_CAPACITY = 2000;
@@ -130,16 +124,12 @@ PurgeableResourceManager::PurgeableResourceManager()
         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(lruCacheMutex_);
-    if (isThreadPoolStarted_) {
-        threadPool_.Stop();
-    }
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     lruCache_.Clear();
 }
 
@@ -159,22 +149,19 @@ void PurgeableResourceManager::BeginAccessPurgeableMem()
         return;
     }
 
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     if (resourcePtrList.size() == 0) {
         FinishTrace(HITRACE_TAG_ZIMAGE);
         return;
     }
 
-    if (!isThreadPoolStarted_) {
-        StartThreadPool();
-    }
-
     for (auto &resourcePtr : resourcePtrList) {
-        if (resourcePtr == nullptr) {
-            continue;
-        }
-        auto task = std::bind(&PurgeableMemBase::BeginReadWithDataLock, resourcePtr);
-        threadPool_.AddTask(task);
+        ffrt::submit([this, resourcePtr] {
+            if (resourcePtr == nullptr) {
+                return;
+            }
+            resourcePtr->BeginReadWithDataLock();
+        });
     }
 
     FinishTrace(HITRACE_TAG_ZIMAGE);
@@ -192,22 +179,19 @@ void PurgeableResourceManager::EndAccessPurgeableMem()
         return;
     }
 
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     if (resourcePtrList.size() == 0) {
         FinishTrace(HITRACE_TAG_ZIMAGE);
         return;
     }
 
-    if (!isThreadPoolStarted_) {
-        StartThreadPool();
-    }
-
     for (auto &resourcePtr : resourcePtrList) {
-        if (resourcePtr == nullptr) {
-            continue;
-        }
-        auto task = std::bind(&PurgeableMemBase::EndReadWithDataLock, resourcePtr);
-        threadPool_.AddTask(task);
+        ffrt::submit([this, resourcePtr] {
+            if (resourcePtr == nullptr) {
+                return;
+            }
+            resourcePtr->EndReadWithDataLock();
+        });
     }
 
     FinishTrace(HITRACE_TAG_ZIMAGE);
@@ -228,19 +212,18 @@ void PurgeableResourceManager::ChangeDataValid(std::shared_ptr<PurgeableMemBase>
 
 void PurgeableResourceManager::AddResource(std::shared_ptr<PurgeableMemBase> resourcePtr)
 {
-    auto task = [this, resourcePtr] () {
+    ffrt::submit([this, resourcePtr] {
         if (resourcePtr == nullptr) {
             return;
         }
         AddResourceInner(resourcePtr);
-    };
-    AddTaskToThreadPool(task);
+    });
 }
 
 void PurgeableResourceManager::AddResourceInner(std::shared_ptr<PurgeableMemBase> resourcePtr)
 {
     StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::AddResource");
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     if (resourcePtr == nullptr) {
         FinishTrace(HITRACE_TAG_ZIMAGE);
         return;
@@ -255,19 +238,18 @@ void PurgeableResourceManager::AddResourceInner(std::shared_ptr<PurgeableMemBase
 void PurgeableResourceManager::RemoveResource(std::shared_ptr<PurgeableMemBase> resourcePtr)
 {
     ChangeDataValid(resourcePtr, false);
-    auto task = [this, resourcePtr] () {
+    ffrt::submit([this, resourcePtr] {
         if (resourcePtr == nullptr) {
             return;
         }
         RemoveResourceInner(resourcePtr);
-    };
-    AddTaskToThreadPool(task);
+    });
 }
 
 void PurgeableResourceManager::RemoveResourceInner(std::shared_ptr<PurgeableMemBase> resourcePtr)
 {
     StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::RemoveResource");
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     if (resourcePtr == nullptr) {
         FinishTrace(HITRACE_TAG_ZIMAGE);
         return;
@@ -275,13 +257,11 @@ void PurgeableResourceManager::RemoveResourceInner(std::shared_ptr<PurgeableMemB
 
     lruCache_.Erase(resourcePtr);
     FinishTrace(HITRACE_TAG_ZIMAGE);
-    PM_HILOG_DEBUG(LOG_CORE, "[PurgeableResourceManager] RemoveResource resourcePtr: 0x%{public}lx, "
-        "list size: %{public}zu", (long)resourcePtr.get(), lruCache_.Size());
 }
 
 void PurgeableResourceManager::SetRecentUsedResource(std::shared_ptr<PurgeableMemBase> resourcePtr)
 {
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     if (resourcePtr == nullptr) {
         return;
     }
@@ -291,19 +271,19 @@ void PurgeableResourceManager::SetRecentUsedResource(std::shared_ptr<PurgeableMe
 
 void PurgeableResourceManager::SetLruCacheCapacity(int32_t capacity)
 {
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     lruCache_.SetCapacity(capacity);
 }
 
 void PurgeableResourceManager::Clear()
 {
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     lruCache_.Clear();
 }
 
 void PurgeableResourceManager::RemoveLastResource()
 {
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     StartTrace(HITRACE_TAG_ZIMAGE, "OHOS::PurgeableMem::PurgeableResourceManager::RemoveLastResource");
     if (lruCache_.Size() == 0) {
         FinishTrace(HITRACE_TAG_ZIMAGE);
@@ -324,7 +304,7 @@ void PurgeableResourceManager::RemoveLastResource()
 
 void PurgeableResourceManager::ShowLruCache() const
 {
-    std::lock_guard<std::mutex> lock(lruCacheMutex_);
+    std::lock_guard<ffrt::mutex> lock(lruCacheMutex_);
     std::list<std::shared_ptr<PurgeableMemBase>> resourcePtrList = lruCache_.GetResourcePtrList();
     int cnt = 0;
     for (auto &resourcePtr : resourcePtrList) {
@@ -334,41 +314,9 @@ void PurgeableResourceManager::ShowLruCache() const
     }
 }
 
-int32_t PurgeableResourceManager::GetThreadPoolTaskNumFromSysPara() const
-{
-    return system::GetIntParameter<int32_t>(THREAD_POOL_TASK_NUMBER_SYS_NAME, THREAD_POOL_TASK_NUMBER);
-}
-
 int32_t PurgeableResourceManager::GetLruCacheCapacityFromSysPara() const
 {
     return system::GetIntParameter<int32_t>(LRU_CACHE_CAPACITY_SYS_NAME, LRU_CACHE_CAPACITY);
 }
-
-void PurgeableResourceManager::StartThreadPool()
-{
-    std::lock_guard<std::mutex> lock(threadPoolMutex_);
-    if (isThreadPoolStarted_) {
-        return;
-    }
-
-    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;
-    }
-
-    threadPool_.Start(threadPoolTaskNum);
-    isThreadPoolStarted_ = true;
-    PM_HILOG_DEBUG(LOG_CORE, "StartThreadPool finish.");
-}
-
-void PurgeableResourceManager::AddTaskToThreadPool(const std::function<void()> &f)
-{
-    if (!isThreadPoolStarted_) {
-        StartThreadPool();
-    }
-
-    threadPool_.AddTask(f);
-}
 } /* namespace PurgeableMem */
 } /* namespace OHOS */
\ No newline at end of file
diff --git a/libpurgeablemem/test/purgeableresourcemanager_test.cpp b/libpurgeablemem/test/purgeableresourcemanager_test.cpp
index df3d66a081c70ebd9b11754250ae2416055acc9d..1a2060dd3138fe14f593d62da38438cf11aa9e0e 100644
--- a/libpurgeablemem/test/purgeableresourcemanager_test.cpp
+++ b/libpurgeablemem/test/purgeableresourcemanager_test.cpp
@@ -125,7 +125,6 @@ HWTEST_F(PurgeableResourceManagerTest, BeginAccessPurgeableMemTest, TestSize.Lev
     PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
     PurgeableResourceManager::GetInstance().lruCache_.Insert(key);
     PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
-    PurgeableResourceManager::GetInstance().isThreadPoolStarted_ = true;
     PurgeableResourceManager::GetInstance().BeginAccessPurgeableMem();
     EXPECT_NE(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
     PurgeableResourceManager::GetInstance().Clear();
@@ -137,7 +136,6 @@ HWTEST_F(PurgeableResourceManagerTest, EndAccessPurgeableMemTest, TestSize.Level
     PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
     PurgeableResourceManager::GetInstance().lruCache_.Insert(key);
     PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
-    PurgeableResourceManager::GetInstance().isThreadPoolStarted_ = true;
     PurgeableResourceManager::GetInstance().EndAccessPurgeableMem();
     EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 1);
     PurgeableResourceManager::GetInstance().Clear();
@@ -192,8 +190,6 @@ HWTEST_F(PurgeableResourceManagerTest, RemoveLastResourceTest, TestSize.Level1)
     PurgeableResourceManager::GetInstance().RemoveLastResource();
     PurgeableResourceManager::GetInstance().ShowLruCache();
     EXPECT_EQ(PurgeableResourceManager::GetInstance().lruCache_.Size(), 0);
-    PurgeableResourceManager::GetInstance().StartThreadPool();
-    PurgeableResourceManager::GetInstance().StartThreadPool();
 }
 }
 }