diff --git a/js_concurrent_module/taskpool/sequence_runner.cpp b/js_concurrent_module/taskpool/sequence_runner.cpp
index f54c44c31a89da888e156d3ace92bcc43e40fbb5..ed746ee651f33f935e642967a109db83e654f3a1 100644
--- a/js_concurrent_module/taskpool/sequence_runner.cpp
+++ b/js_concurrent_module/taskpool/sequence_runner.cpp
@@ -110,14 +110,10 @@ napi_value SequenceRunner::Execute(napi_env env, napi_callback_info cbinfo)
     napi_get_cb_info(env, cbinfo, &argc, args, &thisVar, nullptr);
     std::string errMessage = "";
     if (argc < 1) {
-        errMessage = "seqRunner:: number of params at least one";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the number of param at least one.");
         return nullptr;
     }
     if (!NapiHelper::IsObject(env, args[0]) || !NapiHelper::HasNameProperty(env, args[0], TASKID_STR)) {
-        errMessage = "seqRunner:: first param must be task.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the first param must be task.");
         return nullptr;
     }
diff --git a/js_concurrent_module/taskpool/task.cpp b/js_concurrent_module/taskpool/task.cpp
index fdcd4976d9a4f93519bbb4317979e49e7f47b965..f9bc0e80293f25d846ab2449eef55d13e448847e 100644
--- a/js_concurrent_module/taskpool/task.cpp
+++ b/js_concurrent_module/taskpool/task.cpp
@@ -49,7 +49,6 @@ napi_value Task::TaskConstructor(napi_env env, napi_callback_info cbinfo)
     std::string errMessage = "";
     if (argc < 1) {
         errMessage = "taskpool:: create task need more than one param";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return nullptr;
     }
@@ -71,8 +70,6 @@ napi_value Task::TaskConstructor(napi_env env, napi_callback_info cbinfo)
         argc -= 1; // 1: func
     }
     if (!NapiHelper::IsFunction(env, func)) {
-        errMessage = "taskpool:: the first or second param of task must be function";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the type of the first or second param of task must be function.");
         return nullptr;
@@ -271,7 +268,6 @@ napi_value Task::GetTaskInfoPromise(napi_env env, napi_value task, TaskType task
     napi_value promise = NapiHelper::CreatePromise(env, &taskInfo->deferred);
     if (promise == nullptr) { // LOCV_EXCL_BR_LINE
         std::string err = "create promise failed, maybe has exception.";
-        HILOG_ERROR("taskpool:: %{public}s", err.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, err.c_str());
         return nullptr;
     }
@@ -433,7 +429,6 @@ napi_value Task::OnReceiveData(napi_env env, napi_callback_info cbinfo)
 {
     size_t argc = NapiHelper::GetCallbackInfoArgc(env, cbinfo);
     if (argc >= 2) { // 2: the number of parmas
-        HILOG_ERROR("taskpool:: the number of OnReceiveData parma must be less than 2");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the number of OnReceiveData parma must be less than 2.");
         return nullptr;
@@ -454,7 +449,6 @@ napi_value Task::OnReceiveData(napi_env env, napi_callback_info cbinfo)
     napi_valuetype type;
     NAPI_CALL(env, napi_typeof(env, args[0], &type));
     if (type != napi_function) {
-        HILOG_ERROR("taskpool:: OnReceiveData's parameter should be function");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the type of onReceiveData's parameter must be function.");
         return nullptr;
@@ -487,13 +481,11 @@ napi_value Task::SendData(napi_env env, napi_callback_info cbinfo)
 
     auto engine = reinterpret_cast<NativeEngine*>(env);
     if (!engine->IsTaskPoolThread()) {
-        HILOG_ERROR("taskpool:: SendData is not called in the taskpool thread");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_NOT_IN_TASKPOOL_THREAD);
         return nullptr;
     }
     void* data = engine->GetCurrentTaskInfo();
     if (data == nullptr) {
-        HILOG_ERROR("taskpool:: SendData is not called in the concurrent function");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_NOT_IN_CONCURRENT_FUNCTION);
         return nullptr;
     }
@@ -508,7 +500,6 @@ napi_value Task::SendData(napi_env env, napi_callback_info cbinfo)
                                                          defaultClone, &serializationArgs, errString);
     if (status != napi_ok || serializationArgs == nullptr) {
         std::string errMessage = "taskpool:: failed to serialize function.\nSerialize error: " + errString;
-        HILOG_ERROR("%{public}s in SendData", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_WORKER_SERIALIZATION, errMessage.c_str());
         return nullptr;
     }
@@ -522,8 +513,6 @@ napi_value Task::AddDependency(napi_env env, napi_callback_info cbinfo)
 {
     size_t argc = NapiHelper::GetCallbackInfoArgc(env, cbinfo);
     if (argc == 0) {
-        std::string errMessage = "taskpool:: addDependency has no params";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "addDependency has no params.");
         return nullptr;
     }
@@ -541,24 +530,20 @@ napi_value Task::AddDependency(napi_env env, napi_callback_info cbinfo)
     }
     std::string errMessage = "";
     if (task->IsPeriodicTask()) {
-        HILOG_ERROR("taskpool:: the periodic task cannot have a dependency");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_HAVE_DEPENDENCY);
         return nullptr;
     }
     if (task->IsCommonTask() || task->IsSeqRunnerTask()) {
         errMessage = "taskpool:: seqRunnerTask or executedTask cannot addDependency";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return nullptr;
     }
     if (task->IsAsyncRunnerTask()) {
-        HILOG_ERROR("taskpool:: AsyncRunnerTask cannot addDependency.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_ASYNCRUNNER_TASK_HAVE_DEPENDENCY);
         return nullptr;
     }
     if (task->IsGroupCommonTask()) {
         errMessage = "taskpool:: groupTask cannot addDependency";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return nullptr;
     }
@@ -566,8 +551,6 @@ napi_value Task::AddDependency(napi_env env, napi_callback_info cbinfo)
     std::set<uint32_t> idSet;
     for (size_t i = 0; i < argc; i++) {
         if (!NapiHelper::HasNameProperty(env, args[i], TASKID_STR)) {
-            errMessage = "taskpool:: addDependency param is not task";
-            HILOG_ERROR("%{public}s", errMessage.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of the addDependency param must be task.");
             return nullptr;
         } else {
@@ -578,29 +561,24 @@ napi_value Task::AddDependency(napi_env env, napi_callback_info cbinfo)
                 return nullptr;
             }
             if (dependentTask->taskId_ == task->taskId_) {
-                HILOG_ERROR("taskpool:: there is a circular dependency");
                 ErrorHelper::ThrowError(env, ErrorHelper::ERR_CIRCULAR_DEPENDENCY);
                 return nullptr;
             }
             if (dependentTask->IsPeriodicTask()) {
-                HILOG_ERROR("taskpool:: the periodic task cannot have a dependency");
                 ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_HAVE_DEPENDENCY);
                 return nullptr;
             }
             if (dependentTask->IsCommonTask() || dependentTask->IsSeqRunnerTask()) {
                 errMessage = "taskpool:: seqRunnerTask or executedTask cannot be relied on";
-                HILOG_ERROR("%{public}s", errMessage.c_str());
                 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
                 return nullptr;
             }
             if (dependentTask->IsAsyncRunnerTask()) {
-                HILOG_ERROR("taskpool:: AsyncRunnerTask cannot be relied on.");
                 ErrorHelper::ThrowError(env, ErrorHelper::ERR_ASYNCRUNNER_TASK_HAVE_DEPENDENCY);
                 return nullptr;
             }
             if (dependentTask->IsGroupCommonTask()) {
                 errMessage = "taskpool:: groupTask cannot be relied on";
-                HILOG_ERROR("%{public}s", errMessage.c_str());
                 ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
                 return nullptr;
             }
@@ -609,7 +587,6 @@ napi_value Task::AddDependency(napi_env env, napi_callback_info cbinfo)
         }
     }
     if (!TaskManager::GetInstance().StoreTaskDependency(task->taskId_, idSet)) {
-        HILOG_ERROR("taskpool:: there is a circular dependency");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_CIRCULAR_DEPENDENCY);
     }
     std::string strTrace = "Task::AddDependency: ";
@@ -621,8 +598,6 @@ napi_value Task::RemoveDependency(napi_env env, napi_callback_info cbinfo)
 {
     size_t argc = NapiHelper::GetCallbackInfoArgc(env, cbinfo);
     if (argc == 0) {
-        std::string errMessage = "taskpool:: removeDependency has no params";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "removeDependency has no params.");
         return nullptr;
     }
@@ -634,7 +609,6 @@ napi_value Task::RemoveDependency(napi_env env, napi_callback_info cbinfo)
     Task* task = nullptr;
     napi_unwrap(env, napiTask, reinterpret_cast<void**>(&task));
     if (task == nullptr) {
-        HILOG_ERROR("taskpool:: the task is nullptr");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the task is nullptr");
         return nullptr;
     }
@@ -643,32 +617,26 @@ napi_value Task::RemoveDependency(napi_env env, napi_callback_info cbinfo)
         return nullptr;
     }
     if (task->IsPeriodicTask()) {
-        HILOG_ERROR("taskpool:: the periodic task cannot call removeDependency");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_HAVE_DEPENDENCY);
         return nullptr;
     }
     if (task->IsCommonTask()) {
         std::string errMessage = "taskpool:: executedTask cannot removeDependency";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_INEXISTENT_DEPENDENCY, errMessage.c_str());
         return nullptr;
     }
     if (task->IsAsyncRunnerTask()) {
-        HILOG_ERROR("taskpool:: AsyncRunnerTask cannot call removeDependency.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_ASYNCRUNNER_TASK_HAVE_DEPENDENCY);
         return nullptr;
     }
     for (size_t i = 0; i < argc; i++) {
         if (!NapiHelper::HasNameProperty(env, args[i], TASKID_STR)) {
-            std::string errMessage = "taskpool:: removeDependency param is not task";
-            HILOG_ERROR("%{public}s", errMessage.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of removeDependency param must be task.");
             return nullptr;
         }
         Task* dependentTask = nullptr;
         napi_unwrap(env, args[i], reinterpret_cast<void**>(&dependentTask));
         if (dependentTask == nullptr) {
-            HILOG_ERROR("taskpool:: the dependent task is nullptr");
             ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,  "the dependent task is nullptr");
             return nullptr;
         }
@@ -677,23 +645,19 @@ napi_value Task::RemoveDependency(napi_env env, napi_callback_info cbinfo)
             return nullptr;
         }
         if (dependentTask->IsPeriodicTask()) {
-            HILOG_ERROR("taskpool:: the periodic task cannot call removeDependency");
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_HAVE_DEPENDENCY);
             return nullptr;
         }
         if (dependentTask->IsCommonTask()) {
             std::string errMessage = "taskpool:: cannot removeDependency on a dependent and executed task";
-            HILOG_ERROR("%{public}s", errMessage.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
             return nullptr;
         }
         if (dependentTask->IsAsyncRunnerTask()) {
-            HILOG_ERROR("taskpool:: AsyncRunnerTask cannot call removeDependency.");
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_ASYNCRUNNER_TASK_HAVE_DEPENDENCY);
             return nullptr;
         }
         if (!TaskManager::GetInstance().RemoveTaskDependency(task->taskId_, dependentTask->taskId_)) {
-            HILOG_ERROR("taskpool:: the dependency does not exist");
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_INEXISTENT_DEPENDENCY);
             return nullptr;
         }
@@ -790,7 +754,6 @@ napi_value Task::OnEnqueued(napi_env env, napi_callback_info cbinfo)
     napi_valuetype type;
     NAPI_CALL(env, napi_typeof(env, args[0], &type));
     if (type != napi_function) {
-        HILOG_ERROR("taskpool:: OnEnqueued's parameter should be function");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the type of OnEnqueued's parameter must be function.");
         return nullptr;
     }
@@ -803,7 +766,6 @@ napi_value Task::OnEnqueued(napi_env env, napi_callback_info cbinfo)
     }
 
     if (task->taskState_ != ExecuteState::NOT_FOUND) {
-        HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_REGISTRATION_OF_LISTENERS);
         return nullptr;
     }
@@ -828,7 +790,6 @@ napi_value Task::OnStartExecution(napi_env env, napi_callback_info cbinfo)
     napi_valuetype type;
     NAPI_CALL(env, napi_typeof(env, args[0], &type));
     if (type != napi_function) {
-        HILOG_ERROR("taskpool:: OnStartExecution's parameter should be function");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the type of OnStartExecution's parameter must be function.");
         return nullptr;
@@ -842,7 +803,6 @@ napi_value Task::OnStartExecution(napi_env env, napi_callback_info cbinfo)
     }
 
     if (task->taskState_ != ExecuteState::NOT_FOUND) {
-        HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_REGISTRATION_OF_LISTENERS);
         return nullptr;
     }
@@ -868,7 +828,6 @@ napi_value Task::OnExecutionFailed(napi_env env, napi_callback_info cbinfo)
     napi_valuetype type;
     NAPI_CALL(env, napi_typeof(env, args[0], &type));
     if (type != napi_function) {
-        HILOG_ERROR("taskpool:: OnExecutionFailed's parameter should be function");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the type of OnExecutionFailed's parameter must be function.");
         return nullptr;
@@ -882,7 +841,6 @@ napi_value Task::OnExecutionFailed(napi_env env, napi_callback_info cbinfo)
     }
 
     if (task->taskState_ != ExecuteState::NOT_FOUND) {
-        HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_REGISTRATION_OF_LISTENERS);
         return nullptr;
     }
@@ -907,7 +865,6 @@ napi_value Task::OnExecutionSucceeded(napi_env env, napi_callback_info cbinfo)
     napi_valuetype type;
     NAPI_CALL(env, napi_typeof(env, args[0], &type));
     if (type != napi_function) {
-        HILOG_ERROR("taskpool:: OnExecutionSucceeded's parameter should be function");
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR,
             "the type of OnExecutionSucceeded's parameter must be function");
         return nullptr;
@@ -921,7 +878,6 @@ napi_value Task::OnExecutionSucceeded(napi_env env, napi_callback_info cbinfo)
     }
 
     if (task->taskState_ != ExecuteState::NOT_FOUND) {
-        HILOG_ERROR("taskpool:: The executed task does not support the registration of listeners.");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_REGISTRATION_OF_LISTENERS);
         return nullptr;
     }
@@ -1218,31 +1174,26 @@ bool Task::CanForSequenceRunner(napi_env env)
     // task with dependence is not allowed
     if (HasDependency()) {
         errMessage = "seqRunner:: dependent task not allowed.";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_ADD_DEPENDENT_TASK_TO_SEQRUNNER, errMessage.c_str());
         return false;
     }
     if (IsPeriodicTask()) {
         errMessage = "taskpool:: SequenceRunner cannot execute the periodicTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_EXECUTE_AGAIN, errMessage.c_str());
         return false;
     }
     if (IsCommonTask() || IsSeqRunnerTask()) {
         errMessage = "taskpool:: SequenceRunner cannot execute seqRunnerTask or executedTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsGroupCommonTask()) {
         errMessage = "taskpool:: SequenceRunner cannot execute groupTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsAsyncRunnerTask()) {
         errMessage = "SequenceRunner cannot execute asyncRunnerTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
@@ -1254,37 +1205,31 @@ bool Task::CanForTaskGroup(napi_env env)
     std::string errMessage = "";
     if (HasDependency()) {
         errMessage = "taskpool:: dependent task not allowed.";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsPeriodicTask()) {
         errMessage = "taskpool:: The interface does not support the periodicTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_EXECUTE_AGAIN, errMessage.c_str());
         return false;
     }
     if (IsCommonTask() || IsSeqRunnerTask()) {
         errMessage = "taskpool:: taskGroup cannot add seqRunnerTask or executedTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsGroupCommonTask()) {
         errMessage = "taskpool:: taskGroup cannot add groupTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsLongTask()) {
         errMessage = "taskpool:: The interface does not support the long task";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsAsyncRunnerTask()) {
         errMessage = "TaskGroup cannot execute asyncRunnerTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
@@ -1297,37 +1242,31 @@ bool Task::CanExecute(napi_env env)
     std::string errMessage = "";
     if (IsGroupCommonTask()) {
         errMessage = "taskpool:: groupTask cannot execute outside";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsSeqRunnerTask()) {
         errMessage = "taskpool:: seqRunnerTask cannot execute outside";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsCommonTask() && HasDependency()) {
         errMessage = "taskpool:: executedTask with dependency cannot execute again";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsExecuted() && IsLongTask()) {
         errMessage = "taskpool:: The long task can only be executed once";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsPeriodicTask()) {
         errMessage = "taskpool:: the periodicTask cannot execute again";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_EXECUTE_AGAIN, errMessage.c_str());
         return false;
     }
     if (IsAsyncRunnerTask()) {
         errMessage = "AsyncRunnerTask cannot execute outside.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
@@ -1339,37 +1278,31 @@ bool Task::CanExecuteDelayed(napi_env env)
     std::string errMessage = "";
     if (IsGroupCommonTask()) {
         errMessage = "taskpool:: groupTask cannot executeDelayed outside";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsSeqRunnerTask()) {
         errMessage = "taskpool:: seqRunnerTask cannot executeDelayed outside";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsCommonTask() && HasDependency()) {
         errMessage = "taskpool:: executedTask with dependency cannot executeDelayed again";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsExecuted() && IsLongTask()) {
         errMessage = "taskpool:: Multiple executions of longTask are not supported in the executeDelayed";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return false;
     }
     if (IsPeriodicTask()) {
         errMessage = "taskpool:: the periodicTask cannot executeDelayed";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_EXECUTE_AGAIN, errMessage.c_str());
         return false;
     }
     if (IsAsyncRunnerTask()) {
         errMessage = "AsyncRunnerTask cannot executeDelayed.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
@@ -1421,7 +1354,6 @@ void Task::TryClearHasDependency()
 void Task::ThrowNoDependencyError(napi_env env)
 {
     std::string errMessage = "taskpool:: task has no dependency";
-    HILOG_ERROR("%{public}s", errMessage.c_str());
     ErrorHelper::ThrowError(env, ErrorHelper::ERR_INEXISTENT_DEPENDENCY, errMessage.c_str());
 }
 
@@ -1569,31 +1501,26 @@ bool Task::CanForAsyncRunner(napi_env env)
     std::string errMessage = "";
     if (HasDependency()) {
         errMessage = "AsyncRunner:: dependent task not allowed.";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_ADD_DEPENDENT_TASK_TO_SEQRUNNER, errMessage.c_str());
         return false;
     }
     if (IsPeriodicTask()) {
         errMessage = "AsyncRunner cannot execute the periodicTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_EXECUTE_AGAIN, errMessage.c_str());
         return false;
     }
     if (IsCommonTask() || IsSeqRunnerTask()) {
         errMessage = "AsyncRunner cannot execute seqRunnerTask or executedTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
     if (IsGroupCommonTask()) {
         errMessage = "AsyncRunner cannot execute groupTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
     if (IsAsyncRunnerTask()) {
         errMessage = "AsyncRunner cannot execute asyncRunnerTask.";
-        HILOG_ERROR("taskpool:: %{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_TASK_CANNOT_EXECUTED, errMessage.c_str());
         return false;
     }
@@ -1925,7 +1852,6 @@ std::tuple<napi_value, napi_value, napi_value, napi_value> Task::GetSerializePar
     napi_value args = NapiHelper::GetNameProperty(env, napiTask, ARGUMENTS_STR);
     if (func == nullptr || args == nullptr) {
         std::string errMessage = "taskpool:: task value is error";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return {nullptr, nullptr, nullptr, nullptr};
     }
@@ -1952,7 +1878,6 @@ std::tuple<void*, void*> Task::GetSerializeResult(napi_env env, napi_value func,
     std::string errMessage = "";
     if (status != napi_ok || serializationFunction == nullptr) {
         errMessage = "taskpool: failed to serialize function.\nSerialize error: " + errString;
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_NOT_CONCURRENT_FUNCTION, errMessage.c_str());
         return {nullptr, nullptr};
     }
@@ -1962,7 +1887,6 @@ std::tuple<void*, void*> Task::GetSerializeResult(napi_env env, napi_value func,
                                              defaultCloneSendable, &serializationArguments, errString);
     if (status != napi_ok || serializationArguments == nullptr) { // LOCV_EXCL_BR_LINE
         errMessage = "taskpool: failed to serialize arguments.\nSerialize error: " + errString;
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_WORKER_SERIALIZATION, errMessage.c_str());
         return {nullptr, nullptr};
     }
diff --git a/js_concurrent_module/taskpool/task_group.cpp b/js_concurrent_module/taskpool/task_group.cpp
index f42e153a7cedac72c4286364756ff815dc8a6bba..850acbaebd41ed4a79d36af91b8eaad7df9694af 100644
--- a/js_concurrent_module/taskpool/task_group.cpp
+++ b/js_concurrent_module/taskpool/task_group.cpp
@@ -82,8 +82,6 @@ napi_value TaskGroup::AddTask(napi_env env, napi_callback_info cbinfo)
     size_t argc = NapiHelper::GetCallbackInfoArgc(env, cbinfo);
     std::string errMessage = "";
     if (argc < 1) {
-        errMessage = "taskGroup:: the number of params must be at least one";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, "the number of params must be at least one.");
         return nullptr;
     }
@@ -96,7 +94,6 @@ napi_value TaskGroup::AddTask(napi_env env, napi_callback_info cbinfo)
     TaskGroup* group = TaskGroupManager::GetInstance().GetTaskGroup(groupId);
     if (group == nullptr || group->groupState_ != ExecuteState::NOT_FOUND) {
         errMessage = "taskpool:: executed taskGroup cannot addTask";
-        HILOG_ERROR("%{public}s", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, errMessage.c_str());
         return nullptr;
     }
diff --git a/js_concurrent_module/taskpool/task_group_manager.cpp b/js_concurrent_module/taskpool/task_group_manager.cpp
index fe1ff649c691a528cf5a0fd1ec143268d3baf0dd..3e43e810190efabfad0c579ffe4b37a039585496 100644
--- a/js_concurrent_module/taskpool/task_group_manager.cpp
+++ b/js_concurrent_module/taskpool/task_group_manager.cpp
@@ -91,7 +91,6 @@ void TaskGroupManager::CancelGroup(napi_env env, uint64_t groupId)
         if (taskGroup->currentGroupInfo_ == nullptr || taskGroup->groupState_ == ExecuteState::NOT_FOUND ||
             taskGroup->groupState_ == ExecuteState::FINISHED) {
             std::string errMsg = "taskpool:: taskGroup is not executed or has been executed";
-            HILOG_ERROR("%{public}s", errMsg.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK_GROUP, errMsg.c_str());
             return;
         }
diff --git a/js_concurrent_module/taskpool/task_manager.cpp b/js_concurrent_module/taskpool/task_manager.cpp
index f30c9bb36d8423cc8825d55d3e486c5f05451192..1bae72c7275a0cc3071c60aa80e7261691dd01ae 100644
--- a/js_concurrent_module/taskpool/task_manager.cpp
+++ b/js_concurrent_module/taskpool/task_manager.cpp
@@ -577,7 +577,9 @@ template <bool needCheckIdle>
 void TaskManager::TryExpandWithCheckIdle()
 {
     if (GetNonIdleTaskNum() == 0) {
-        HILOG_INFO("taskpool:: no need expand");
+        if constexpr (!needCheckIdle) {
+            HILOG_INFO("taskpool:: no need expand");
+        }
         return;
     }
 
@@ -663,7 +665,6 @@ void TaskManager::CancelTask(napi_env env, uint32_t taskId)
     Task* task = GetTask(taskId);
     if (task == nullptr) {
         std::string errMsg = "taskpool:: the task may not exist";
-        HILOG_ERROR("%{public}s", errMsg.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str());
         return;
     }
@@ -676,7 +677,6 @@ void TaskManager::CancelTask(napi_env env, uint32_t taskId)
         if (task->currentTaskInfo_ == nullptr || task->taskState_ == ExecuteState::NOT_FOUND ||
             task->taskState_ == ExecuteState::FINISHED || task->taskState_ == ExecuteState::ENDING) {
             std::string errMsg = "taskpool:: task is not executed or has been executed";
-            HILOG_ERROR("%{public}s", errMsg.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str());
             return;
         }
@@ -709,7 +709,6 @@ void TaskManager::CancelTask(napi_env env, uint32_t taskId)
             task->taskState_ == ExecuteState::NOT_FOUND || task->taskState_ == ExecuteState::FINISHED ||
             task->taskState_ == ExecuteState::ENDING) {
             std::string errMsg = "taskpool:: task is not executed or has been executed";
-            HILOG_ERROR("%{public}s", errMsg.c_str());
             ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str());
             return;
         }
@@ -733,7 +732,6 @@ void TaskManager::CancelSeqRunnerTask(napi_env env, Task* task)
         }
     }
     std::string errMsg = "taskpool:: sequenceRunner task has been executed";
-    HILOG_ERROR("%{public}s", errMsg.c_str());
     ErrorHelper::ThrowError(env, ErrorHelper::ERR_CANCEL_NONEXIST_TASK, errMsg.c_str());
 }
 
@@ -1083,7 +1081,6 @@ void TaskManager::ExecuteSendData(napi_env env, TaskResultInfo* resultInfo, uint
     std::lock_guard<std::mutex> lock(callbackMutex_);
     auto iter = callbackTable_.find(taskId);
     if (iter == callbackTable_.end() || iter->second == nullptr) {
-        HILOG_ERROR("taskpool:: the callback in SendData is not registered on the host side");
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_NOT_REGISTERED);
         delete resultInfo;
         return;
diff --git a/js_concurrent_module/taskpool/taskpool.cpp b/js_concurrent_module/taskpool/taskpool.cpp
index 34969a67c8887e176306eef132a927cd628811ef..d0b67920bf6388dc4dd2e8d21f252e52c66b0316 100644
--- a/js_concurrent_module/taskpool/taskpool.cpp
+++ b/js_concurrent_module/taskpool/taskpool.cpp
@@ -123,7 +123,6 @@ void TaskPool::ExecuteOnReceiveDataCallback(CallbackInfo* callbackInfo, TaskResu
     napi_delete_serialization_data(env, resultInfo->serializationArgs);
     if (status != napi_ok || args == nullptr) {
         std::string errMessage = "taskpool:: failed to serialize function";
-        HILOG_ERROR("%{public}s in SendData", errMessage.c_str());
         ErrorHelper::ThrowError(env, ErrorHelper::ERR_WORKER_SERIALIZATION, errMessage.c_str());
         return;
     }
@@ -243,7 +242,6 @@ napi_value TaskPool::Execute(napi_env env, napi_callback_info cbinfo)
         }
         std::string err = "create promise failed, maybe has exception.";
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, err.c_str());
-        HILOG_ERROR("taskpool:: Execute %{public}s", err.c_str());
         return nullptr;
     }
     ExecuteTask(env, task);
@@ -323,7 +321,6 @@ napi_value TaskPool::ExecuteDelayed(napi_env env, napi_callback_info cbinfo)
         taskMessage = nullptr;
         std::string err = "create promise failed, maybe has exception.";
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, err.c_str());
-        HILOG_ERROR("taskpool:: ExecuteDelayed %{public}s", err.c_str());
         return nullptr;
     }
     uv_loop_t* loop = NapiHelper::GetLibUV(env);
@@ -379,7 +376,6 @@ napi_value TaskPool::ExecuteGroup(napi_env env, napi_value napiTaskGroup, Priori
         groupInfo = nullptr;
         std::string err = "create promise failed, maybe has exception.";
         ErrorHelper::ThrowError(env, ErrorHelper::TYPE_ERROR, err.c_str());
-        HILOG_ERROR("taskpool:: ExecuteGroup %{public}s", err.c_str());
         return nullptr;
     }
     {