diff --git a/src/common/dss_defs.h b/src/common/dss_defs.h
index 3da3ffb013b2064c8945aad8934e724c2e18dc4e..bd029f4895c3242e74f29b6343b76dd974538651 100644
--- a/src/common/dss_defs.h
+++ b/src/common/dss_defs.h
@@ -39,7 +39,7 @@ extern "C" {
 #define DSS_FKEY_FILENAME "server.key.rand"
 #define DSS_MAX_AUDIT_PATH_LENGTH (SIZE_K(2) + 512)
 
-#define DSS_VG_ALARM_CHECK_COUNT 10
+#define DSS_VG_ALARM_CHECK_CYCLE 10000
 #define DSS_VG_USAGE_MIN 0
 #define DSS_VG_USAGE_MAX 100
 
diff --git a/src/service/dss_instance.c b/src/service/dss_instance.c
index 3b3fe11ba92f0f186348d87797442a45fe43a90a..9e3f2126532887ca1fd9f1a5c89009adff72ae63 100644
--- a/src/service/dss_instance.c
+++ b/src/service/dss_instance.c
@@ -820,25 +820,27 @@ void dss_get_cm_lock_and_recover_inner(dss_session_t *session, dss_instance_t *i
     cm_unlatch(&g_dss_instance.switch_latch, LATCH_STAT(LATCH_SWITCH));
 }
 
-#define DSS_RECOVER_INTERVAL 500
-#define DSS_SHORT_RECOVER_INTERVAL 100
 void dss_get_cm_lock_and_recover(thread_t *thread)
 {
     cm_set_thread_name("recovery");
     uint32 work_idx = dss_get_recover_task_idx();
     dss_session_t *session = dss_get_reserv_session(work_idx);
     dss_instance_t *inst = (dss_instance_t *)thread->argument;
+    uint32 sleep_times = 0;
     while (!thread->closed) {
-        dss_get_cm_lock_and_recover_inner(session, inst);
-        if (inst->status == DSS_STATUS_PREPARE) {
-            LOG_RUN_WAR("[RECOVERY]Try to sleep when in prepare status.\n");
-            cm_sleep(DSS_SHORT_RECOVER_INTERVAL);
-        } else {
-            cm_sleep(DSS_RECOVER_INTERVAL);
+        uint32 execute_cycle = inst->status == DSS_STATUS_PREPARE ? CM_SLEEP_100_FIXED : CM_SLEEP_500_FIXED;
+        if (sleep_times >= execute_cycle / CM_SLEEP_100_FIXED) {
+            sleep_times = 0;
         }
+        if (sleep_times == 0) {
+            dss_get_cm_lock_and_recover_inner(session, inst);
+        }
+        cm_sleep(CM_SLEEP_100_FIXED);
+        ++sleep_times;
     }
 }
 
+#define DSS_SLEEP_200_MS 200
 void dss_delay_clean_proc(thread_t *thread)
 {
     cm_set_thread_name("delay_clean");
@@ -848,10 +850,11 @@ void dss_delay_clean_proc(thread_t *thread)
     LOG_RUN_INF("Session[id=%u] is available for delay clean task.", session->id);
     dss_config_t *inst_cfg = dss_get_inst_cfg();
     uint32 sleep_times = 0;
+    uint32 execute_cycle = inst_cfg->params.delay_clean_interval * CM_SLEEP_1000_FIXED / DSS_SLEEP_200_MS;
     while (!thread->closed) {
-        if (sleep_times < inst_cfg->params.delay_clean_interval) {
-            cm_sleep(CM_SLEEP_1000_FIXED);
-            sleep_times++;
+        if (sleep_times < execute_cycle) {
+            cm_sleep(DSS_SLEEP_200_MS);
+            ++sleep_times;
             continue;
         }
         g_dss_instance.is_cleaning = CM_TRUE;
@@ -872,17 +875,19 @@ void dss_alarm_check_proc(thread_t *thread)
     dss_session_ctrl_t *session_ctrl = dss_get_session_ctrl();
     dss_session_t *session = session_ctrl->sessions[work_idx];
     // for check other alarms
-    uint32 alarm_counts = DSS_VG_ALARM_CHECK_COUNT;
+    uint32 execute_cycle = DSS_VG_ALARM_CHECK_CYCLE / DSS_SLEEP_200_MS;
     while (!thread->closed) {
-        // only master node need alarm
-        if (sleep_times % DSS_VG_ALARM_CHECK_COUNT == 0) {
+        if (sleep_times >= execute_cycle) {
+            sleep_times = 0;
+        }
+        if (sleep_times == 0) {
+            // only master node need alarm
             g_dss_instance.is_checking = CM_TRUE;
             dss_alarm_check_vg_usage(session);
             g_dss_instance.is_checking = CM_FALSE;
         }
-        cm_sleep(CM_SLEEP_500_FIXED);
-        sleep_times++;
-        sleep_times = sleep_times % alarm_counts;
+        cm_sleep(DSS_SLEEP_200_MS);
+        ++sleep_times;
     }
 }
 
@@ -892,12 +897,20 @@ void dss_hashmap_dynamic_extend_and_redistribute_proc(thread_t *thread)
     uint32 work_idx = dss_get_hashmap_dynamic_extend_task_idx();
     dss_session_ctrl_t *session_ctrl = dss_get_session_ctrl();
     dss_session_t *session = session_ctrl->sessions[work_idx];
+    uint32 sleep_times = 0;
+    uint32 execute_cycle = CM_SLEEP_500_FIXED / CM_SLEEP_100_FIXED;
     while (!thread->closed) {
-        for (uint32_t i = 0; i < g_vgs_info->group_num; i++) {
-            dss_vg_info_item_t *vg_item = &g_vgs_info->volume_group[i];
-            dss_hashmap_dynamic_extend_and_redistribute_per_vg(vg_item, session);
+        if (sleep_times >= execute_cycle) {
+            sleep_times = 0;
+        }
+        if (sleep_times == 0) {
+            for (uint32_t i = 0; i < g_vgs_info->group_num; i++) {
+                dss_vg_info_item_t *vg_item = &g_vgs_info->volume_group[i];
+                dss_hashmap_dynamic_extend_and_redistribute_per_vg(vg_item, session);
+            }
         }
-        cm_sleep(CM_SLEEP_500_FIXED);
+        cm_sleep(CM_SLEEP_100_FIXED);
+        ++sleep_times;
     }
 }
 static void dss_check_peer_inst_inner(dss_instance_t *inst)
diff --git a/src/service/dssserver.c b/src/service/dssserver.c
index e5f99f9c1f88b07fab6ce643e5e7e96404d16b8b..06dbc12b7cbd920af6c2707f8afc0efdfe79b05d 100644
--- a/src/service/dssserver.c
+++ b/src/service/dssserver.c
@@ -77,9 +77,16 @@ static void dss_close_background_task(dss_instance_t *inst)
 {
     uint32 bg_task_base_id = dss_get_udssession_startid() - (uint32)DSS_BACKGROUND_TASK_NUM;
     for (uint32 i = 0; i < DSS_BACKGROUND_TASK_NUM; i++) {
-        uint32 bg_task_id = bg_task_base_id + i;
-        if (inst->threads[bg_task_id].id != 0) {
-            cm_close_thread(&inst->threads[bg_task_id]);
+        thread_t *bg_thread = &inst->threads[bg_task_base_id + i];
+        if (bg_thread->id != 0) {
+            bg_thread->closed = CM_TRUE;
+        }
+    }
+
+    for (uint32 i = 0; i < DSS_BACKGROUND_TASK_NUM; i++) {
+        thread_t *bg_thread = &inst->threads[bg_task_base_id + i];
+        if (bg_thread->id != 0) {
+            cm_close_thread(bg_thread);
         }
     }
 }
@@ -142,25 +149,33 @@ static void dss_clean_server()
 static void handle_main_wait(void)
 {
     int64 periods = 0;
-    uint32 interval = 500;
+    uint32 sleep_times = 0;
+    uint32 execute_cycle = 500;
     do {
         if (g_dss_instance.abort_status == CM_TRUE) {
             break;
         }
-        if (!g_dss_instance.is_maintain) {
-            dss_check_peer_inst(&g_dss_instance, DSS_INVALID_ID64);
-        }
-        if (periods == MILLISECS_PER_SECOND * SECONDS_PER_DAY / interval) {
-            periods = 0;
-            dss_ssl_ca_cert_expire();
+        if (sleep_times >= (execute_cycle / CM_SLEEP_100_FIXED)) {
+            sleep_times = 0;
         }
-        if (dss_is_readwrite()) {
-            dss_check_unreg_volume(g_dss_instance.handle_session);
+        if (sleep_times == 0) {
+            if (!g_dss_instance.is_maintain) {
+                dss_check_peer_inst(&g_dss_instance, DSS_INVALID_ID64);
+            }
+            if (periods == MILLISECS_PER_SECOND * SECONDS_PER_DAY / execute_cycle) {
+                periods = 0;
+                dss_ssl_ca_cert_expire();
+            }
+            if (dss_is_readwrite()) {
+                dss_check_unreg_volume(g_dss_instance.handle_session);
+            }
+
+            dss_clean_all_sessions_latch();
+            periods++;
         }
 
-        dss_clean_all_sessions_latch();
-        cm_sleep(interval);
-        periods++;
+        cm_sleep(CM_SLEEP_100_FIXED);
+        ++sleep_times;
     } while (CM_TRUE);
     dss_clean_server();
 }