diff --git a/services/distributedhardwarefwkservice/test/fuzztest/accessmanager_fuzzer/accessmanager_fuzzer.cpp b/services/distributedhardwarefwkservice/test/fuzztest/accessmanager_fuzzer/accessmanager_fuzzer.cpp
index f181c732048ced38649b248d4643eeae9cd6bc71..d91c89b152ae5f6a695bf60db74ef65cea665ce9 100644
--- a/services/distributedhardwarefwkservice/test/fuzztest/accessmanager_fuzzer/accessmanager_fuzzer.cpp
+++ b/services/distributedhardwarefwkservice/test/fuzztest/accessmanager_fuzzer/accessmanager_fuzzer.cpp
@@ -20,6 +20,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <string>
+#include <unistd.h>
 
 #include "access_manager.h"
 #include "distributed_hardware_errno.h"
@@ -27,7 +28,10 @@
 
 namespace OHOS {
 namespace DistributedHardware {
-constexpr uint16_t TEST_DEV_TYPE_PAD = 0x11;
+namespace {
+    constexpr uint16_t TEST_DEV_TYPE_PAD = 0x11;
+    constexpr uint32_t SLEEP_TIME_US = 10 * 1000;
+}
 
 void AccessManagerFuzzTest(const uint8_t* data, size_t size)
 {
@@ -40,6 +44,7 @@ void AccessManagerFuzzTest(const uint8_t* data, size_t size)
 
     DistributedHardwareManagerFactory::GetInstance().SendOnLineEvent(
         networkId, uuid, TEST_DEV_TYPE_PAD);
+    usleep(SLEEP_TIME_US);
 }
 }
 }
diff --git a/services/distributedhardwarefwkserviceimpl/include/task/monitor_task_timer.h b/services/distributedhardwarefwkserviceimpl/include/task/monitor_task_timer.h
index e9692c14da60cd1b5f11c2335a4b30bcea49dfec..c3942035177ee86b6811f018672817b165567bea 100644
--- a/services/distributedhardwarefwkserviceimpl/include/task/monitor_task_timer.h
+++ b/services/distributedhardwarefwkserviceimpl/include/task/monitor_task_timer.h
@@ -16,6 +16,7 @@
 #ifndef DISTRIBUTED_HARDWARE_FWK_MONITOR_TASK_TIMER_H
 #define DISTRIBUTED_HARDWARE_FWK_MONITOR_TASK_TIMER_H
 
+#include <condition_variable>
 #include <cstdint>
 #include <memory>
 #include <mutex>
@@ -33,13 +34,19 @@ public:
     ~MonitorTaskTimer();
     void StartTimer();
     void StopTimer();
+    void StartEventRunner();
 
 private:
     MonitorTaskTimer();
     void Execute(const std::shared_ptr<OHOS::AppExecFwk::EventHandler> eventHandler);
+    void InitTimer();
+    void ReleaseTimer();
 
 private:
-    std::thread monitorTaskTimerThread_;
+    std::thread eventHandlerThread_;
+    std::mutex monitorTaskTimerMutex_;
+    std::condition_variable monitorTaskTimerCond_;
+    std::shared_ptr<OHOS::AppExecFwk::EventHandler> eventHandler_;
 };
 } // namespace DistributedHardware
 } // namespace OHOS
diff --git a/services/distributedhardwarefwkserviceimpl/src/task/monitor_task_timer.cpp b/services/distributedhardwarefwkserviceimpl/src/task/monitor_task_timer.cpp
index b27f0c185d4108e85fc0f33ff5eed02e1adeca69..3f69e276505819ad4d6f44992b1d18cb59d5f8d9 100644
--- a/services/distributedhardwarefwkserviceimpl/src/task/monitor_task_timer.cpp
+++ b/services/distributedhardwarefwkserviceimpl/src/task/monitor_task_timer.cpp
@@ -27,7 +27,6 @@ namespace OHOS {
 namespace DistributedHardware {
 IMPLEMENT_SINGLE_INSTANCE(MonitorTaskTimer);
 namespace {
-    const std::string MONITOR_TASK_TIMER_HANDLER = "monitor_task_timer_handler";
     const std::string MONITOR_TASK_TIMER_ID = "monitor_task_timer_id";
     constexpr int32_t DELAY_TIME_MS = 5000;
 }
@@ -42,26 +41,67 @@ MonitorTaskTimer::MonitorTaskTimer()
 MonitorTaskTimer::~MonitorTaskTimer()
 {
     DHLOGI("MonitorTaskTimer destruction");
+    ReleaseTimer();
+}
+
+void MonitorTaskTimer::InitTimer()
+{
+    DHLOGI("start");
+    std::unique_lock<std::mutex> lock(monitorTaskTimerMutex_);
+    if (eventHandler_ == nullptr) {
+        eventHandlerThread_ = std::thread(&MonitorTaskTimer::StartEventRunner, this);
+        monitorTaskTimerCond_.wait(lock, [this] {
+            return eventHandler_ != nullptr;
+        });
+    }
+    DHLOGI("end");
+}
+
+void MonitorTaskTimer::ReleaseTimer()
+{
+    DHLOGI("start");
+    StopTimer();
+    DHLOGI("end");
+}
+
+void MonitorTaskTimer::StartEventRunner()
+{
+    DHLOGI("start");
+    auto busRunner = AppExecFwk::EventRunner::Create(false);
+    {
+        std::lock_guard<std::mutex> lock(monitorTaskTimerMutex_);
+        eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(busRunner);
+    }
+    monitorTaskTimerCond_.notify_all();
+    busRunner->Run();
+    DHLOGI("end");
 }
 
 void MonitorTaskTimer::StartTimer()
 {
     DHLOGI("start");
-    auto busRunner = OHOS::AppExecFwk::EventRunner::Create(MONITOR_TASK_TIMER_HANDLER);
-    auto eventHandler = std::make_shared<OHOS::AppExecFwk::EventHandler>(busRunner);
-    if (eventHandler == nullptr) {
-        DHLOGI("eventHandler construction, this point is empty");
+    InitTimer();
+    std::lock_guard<std::mutex> lock(monitorTaskTimerMutex_);
+    if (eventHandler_ == nullptr) {
+        DHLOGE("eventHandler is nullptr!");
         return;
     }
-    monitorTaskTimerThread_ = std::thread(&MonitorTaskTimer::Execute, this, eventHandler);
+    auto monitorTaskTimer = [this] {Execute(eventHandler_);};
+    eventHandler_->PostTask(monitorTaskTimer, MONITOR_TASK_TIMER_ID, DELAY_TIME_MS);
 }
 
 void MonitorTaskTimer::StopTimer()
 {
     DHLOGI("start");
-    if (monitorTaskTimerThread_.joinable()) {
-        monitorTaskTimerThread_.join();
+    std::lock_guard<std::mutex> lock(monitorTaskTimerMutex_);
+    if (eventHandler_ != nullptr) {
+        eventHandler_->RemoveTask(MONITOR_TASK_TIMER_ID);
+        eventHandler_->GetEventRunner()->Stop();
+    }
+    if (eventHandlerThread_.joinable()) {
+        eventHandlerThread_.join();
     }
+    eventHandler_ = nullptr;
     DHLOGI("end");
 }