diff --git a/services/form_render_service/include/form_render_impl.h b/services/form_render_service/include/form_render_impl.h
index 10795cac5cc700bb918f0b12f627e65e53d9162e..8b17384949c2ad26cc1b656bbd28188cb368042b 100644
--- a/services/form_render_service/include/form_render_impl.h
+++ b/services/form_render_service/include/form_render_impl.h
@@ -104,7 +104,23 @@ private:
     void FormRenderGC(const std::string &uid);
     void OnConfigurationUpdatedInner();
     void ConfirmUnlockState(Want &renderWant);
+    void SetFormSupplyClient(const sptr<IFormSupply>& formSupplyClient);
 
+    sptr<IFormSupply> GetFormSupplyClient();
+
+    int32_t UpdateRenderRecordByUid(const std::string& uid, Want &formRenderWant, const FormJsInfo &formJsInfo,
+                                    const sptr<IFormSupply>& formSupplyClient);
+
+    void GetRenderRecordById(std::shared_ptr<FormRenderRecord>& search, const std::string& uid);
+
+    int32_t RecoverFormByUid(const FormJsInfo &formJsInfo, const Want &want, const std::string& uid,
+                             const std::string& statusData);
+
+    int32_t RecycleFormByUid(const std::string& uid, std::string& statusData, const int64_t formId);
+
+    int32_t DeleteRenderRecordByUid(const std::string& uid, const std::shared_ptr<FormRenderRecord>& search);
+
+private:
     std::mutex renderRecordMutex_;
     // <uid(userId + bundleName), renderRecord>
     std::unordered_map<std::string, std::shared_ptr<FormRenderRecord>> renderRecordMap_;
diff --git a/services/form_render_service/include/form_render_record.h b/services/form_render_service/include/form_render_record.h
index 47d95171f6d5061e6a961de20ee004ab328c9385..0df41dd2e8f6c5b75fc9935837fbf83a8e4acf48 100644
--- a/services/form_render_service/include/form_render_record.h
+++ b/services/form_render_service/include/form_render_record.h
@@ -275,6 +275,35 @@ private:
 
     bool CheckManagerDelegateValid(const FormJsInfo &formJsInfo, const Want &want);
 
+    void SetFormSupplyClient(const sptr<IFormSupply>& formSupplyClient);
+
+    sptr<IFormSupply> GetFormSupplyClient();
+
+    std::shared_ptr<EventHandler> GetEventHandler();
+
+    int32_t AddHostByFormId(int64_t formId, const sptr<IRemoteObject> hostRemoteObj);
+
+    void DeleteHostRemoteObjByFormId(int64_t formId, const sptr<IRemoteObject> hostRemoteObj);
+
+    void DeleteRecycledFormCompIds(int64_t formId);
+
+    void InsertRecycledFormCompIds(int64_t formId, const std::pair<std::vector<std::string>, std::string>& compIds);
+
+    void DeleteHostByFormId(int64_t formId, const sptr<IRemoteObject> hostRemoteObj);
+
+    void RemoveHostByFormId(int64_t formId);
+
+    bool IsFormContextExist(const FormJsInfo &formJsInfo);
+
+    bool GetFormRequestByFormId(int64_t formId, std::unordered_map<std::string, Ace::FormRequest>& formRequests);
+
+    void SetEventHandlerNeedResetFlag(bool needReset);
+
+    bool GetEventHandlerNeedReset();
+
+    void DeleteAndUpdateRecycledFormCompIds(int64_t formId,
+        const std::pair<std::vector<std::string>, std::string>& compIds, const bool needUpdate);
+
     pid_t jsThreadId_ = 0;
     pid_t processId_ = 0;
 
diff --git a/services/form_render_service/src/form_render_impl.cpp b/services/form_render_service/src/form_render_impl.cpp
index 4a38186938a71f9bbcdc0cc138b14ac49ddb9e2c..a1a816850487815286eef83f92c4260317c787ff 100644
--- a/services/form_render_service/src/form_render_impl.cpp
+++ b/services/form_render_service/src/form_render_impl.cpp
@@ -79,46 +79,20 @@ int32_t FormRenderImpl::RenderForm(const FormJsInfo &formJsInfo, const Want &wan
         formJsInfo.formId);
 
     sptr<IFormSupply> formSupplyClient = iface_cast<IFormSupply>(callerToken);
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        if (formSupplyClient == nullptr) {
-            HILOG_ERROR("null IFormSupply");
-            return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
-        }
-        formSupplyClient_ = formSupplyClient;
+    if (formSupplyClient == nullptr) {
+        HILOG_ERROR("null IFormSupply");
+        return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
     }
-    HILOG_DEBUG("connectId:%{public}d",
-        want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
+    SetFormSupplyClient(formSupplyClient);
+    HILOG_DEBUG("connectId:%{public}d", want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
 
     std::string uid = want.GetStringParam(Constants::FORM_SUPPLY_UID);
     if (uid.empty()) {
         HILOG_ERROR("GetUid failed");
         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
     }
-    int32_t result = ERR_OK;
     Want formRenderWant(want);
-    sptr<IRemoteObject> hostToken = formRenderWant.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
-    {
-        std::lock_guard<std::mutex> lock(renderRecordMutex_);
-        ConfirmUnlockState(formRenderWant);
-        if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
-            result = search->second->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
-        } else {
-            auto record = FormRenderRecord::Create(formJsInfo.bundleName, uid, formJsInfo.isDynamic, formSupplyClient);
-            if (record == nullptr) {
-                HILOG_ERROR("null record");
-                return RENDER_FORM_FAILED;
-            }
-
-            record->SetConfiguration(configuration_);
-            result = record->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
-            if (renderRecordMap_.empty()) {
-                FormMemmgrClient::GetInstance().SetCritical(true);
-            }
-            renderRecordMap_.emplace(uid, record);
-            FormRenderGCTask(uid);
-        }
-    }
+    const auto result = UpdateRenderRecordByUid(uid, formRenderWant, formJsInfo, formSupplyClient);
     formSupplyClient->OnRenderTaskDone(formJsInfo.formId, formRenderWant);
     return result;
 }
@@ -143,37 +117,21 @@ int32_t FormRenderImpl::StopRenderingForm(const FormJsInfo &formJsInfo, const Wa
     sptr<IRemoteObject> hostToken = want.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
     {
         std::shared_ptr<FormRenderRecord> search = nullptr;
-        {
-            std::lock_guard<std::mutex> lock(renderRecordMutex_);
-            auto iterator = renderRecordMap_.find(uid);
-            if (iterator == renderRecordMap_.end() || !(iterator->second)) {
-                HILOG_ERROR("fail");
-                return RENDER_FORM_FAILED;
-            }
-            search = iterator->second;
+        GetRenderRecordById(search, uid);
+        if (search == nullptr) {
+            HILOG_ERROR("get render record fail");
+            return RENDER_FORM_FAILED;
         }
 
         std::string compId = want.GetStringParam(Constants::FORM_RENDER_COMP_ID);
         search->DeleteRenderRecord(formJsInfo.formId, compId, hostToken, isRenderGroupEmpty);
-        {
-            std::lock_guard<std::mutex> lock(renderRecordMutex_);
-            if (search->IsEmpty() && !search->HasRenderFormTask()) {
-                auto iterator = renderRecordMap_.find(uid);
-                if (iterator == renderRecordMap_.end()) {
-                    HILOG_ERROR("fail.");
-                    return RENDER_FORM_FAILED;
-                }
-                renderRecordMap_.erase(iterator);
-                HILOG_INFO("DeleteRenderRecord success,uid:%{public}s", uid.c_str());
-                if (renderRecordMap_.empty()) {
-                    FormMemmgrClient::GetInstance().SetCritical(false);
-                }
-            }
+        const auto result = DeleteRenderRecordByUid(uid, search);
+        if (result != ERR_OK) {
+            return result;
         }
     }
 
-    HILOG_INFO("connectId:%{public}d",
-        want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
+    HILOG_INFO("connectId:%{public}d", want.GetIntParam(Constants::FORM_CONNECT_ID, 0L));
     if (isRenderGroupEmpty) {
         formSupplyClient->OnStopRenderingTaskDone(formJsInfo.formId, want);
     }
@@ -184,21 +142,17 @@ int32_t FormRenderImpl::StopRenderingForm(const FormJsInfo &formJsInfo, const Wa
 int32_t FormRenderImpl::ReleaseRenderer(int64_t formId, const std::string &compId, const std::string &uid)
 {
     HILOG_INFO("formId:%{public}" PRId64 ",compId:%{public}s,uid:%{public}s", formId, compId.c_str(), uid.c_str());
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
+    if (formId <= 0 || compId.empty() || uid.empty()) {
+        HILOG_ERROR("param invalid");
+        return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
     }
+
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient");
         return FORM_CLIENT_INVALID;
     }
 
-    if (formId <= 0 || compId.empty() || uid.empty()) {
-        HILOG_ERROR("param invalid");
-        return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
-    }
-
     std::lock_guard<std::mutex> lock(renderRecordMutex_);
     bool isRenderGroupEmpty = false;
     auto search = renderRecordMap_.find(uid);
@@ -251,14 +205,10 @@ int32_t FormRenderImpl::ReloadForm(const std::vector<FormJsInfo> &&formJsInfos,
         return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
     }
     std::shared_ptr<FormRenderRecord> search = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(renderRecordMutex_);
-        auto iterator = renderRecordMap_.find(uid);
-        if (iterator == renderRecordMap_.end()) {
-            HILOG_ERROR("RenderRecord not find");
-            return RELOAD_FORM_FAILED;
-        }
-        search = iterator->second;
+    GetRenderRecordById(search, uid);
+    if (search == nullptr) {
+        HILOG_ERROR("RenderRecord not find");
+        return RELOAD_FORM_FAILED;
     }
     if (search != nullptr) {
         search->ReloadFormRecord(std::forward<decltype(formJsInfos)>(formJsInfos), want);
@@ -356,11 +306,7 @@ void FormRenderImpl::OnConfigurationUpdated(
 
 void FormRenderImpl::OnConfigurationUpdatedInner()
 {
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
-    }
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient");
     }
@@ -455,31 +401,13 @@ int32_t FormRenderImpl::RecycleForm(const int64_t &formId, const Want &want)
     HILOG_INFO("formId:%{public}" PRId64 ",uid:%{public}s", formId, uid.c_str());
 
     std::string statusData;
-    {
-        std::lock_guard<std::mutex> lock(renderRecordMutex_);
-        if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
-            if (search->second == nullptr) {
-                HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
-                return RECYCLE_FORM_FAILED;
-            }
-            auto ret = search->second->RecycleForm(formId, statusData);
-            if (ret != ERR_OK) {
-                return ret;
-            }
-        } else {
-            HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
-            return RECYCLE_FORM_FAILED;
-        }
-        if (statusData.empty()) {
-            HILOG_WARN("empty statusData of %{public}s", std::to_string(formId).c_str());
-        }
+    const auto result = RecycleFormByUid(uid, statusData, formId);
+    if (result != ERR_OK) {
+        HILOG_ERROR("RecycleFormByUid failed");
+        return result;
     }
 
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
-    }
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient, formId:%{public}" PRId64, formId);
         return RECYCLE_FORM_FAILED;
@@ -511,19 +439,7 @@ int32_t FormRenderImpl::RecoverForm(const FormJsInfo &formJsInfo, const Want &wa
     if (statusData.empty()) {
         HILOG_WARN("empty statusData of %{public}s", std::to_string(formId).c_str());
     }
-
-    bool isRecoverFormToHandleClickEvent = want.GetBoolParam(
-        Constants::FORM_IS_RECOVER_FORM_TO_HANDLE_CLICK_EVENT, false);
-    std::lock_guard<std::mutex> lock(renderRecordMutex_);
-    if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
-        if (search->second == nullptr) {
-            HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
-            return RECYCLE_FORM_FAILED;
-        }
-        return search->second->RecoverForm(formJsInfo, statusData, isRecoverFormToHandleClickEvent);
-    }
-    HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
-    return RENDER_FORM_FAILED;
+    return RecoverFormByUid(formJsInfo, want, uid, statusData);
 }
 
 void FormRenderImpl::ConfirmUnlockState(Want &renderWant)
@@ -557,6 +473,123 @@ int32_t FormRenderImpl::UpdateFormSize(
     HILOG_ERROR("can't find render record of %{public}" PRId64, formId);
     return UPDATE_FORM_SIZE_FAILED;
 }
+
+void FormRenderImpl::SetFormSupplyClient(const sptr<IFormSupply>& formSupplyClient)
+{
+    std::lock_guard<std::mutex> lock(formSupplyMutex_);
+    formSupplyClient_ = formSupplyClient;
+}
+
+sptr<IFormSupply> FormRenderImpl::GetFormSupplyClient()
+{
+    std::lock_guard<std::mutex> lock(formSupplyMutex_);
+    return formSupplyClient_;
+}
+
+int32_t FormRenderImpl::UpdateRenderRecordByUid(const std::string& uid, Want &formRenderWant,
+                                                const FormJsInfo &formJsInfo, const sptr<IFormSupply>& formSupplyClient)
+{
+    if (formSupplyClient == nullptr) {
+        HILOG_ERROR("null IFormSupply");
+        return ERR_APPEXECFWK_FORM_BIND_PROVIDER_FAILED;
+    }
+    int32_t result = ERR_OK;
+    sptr<IRemoteObject> hostToken = formRenderWant.GetRemoteObject(Constants::PARAM_FORM_HOST_TOKEN);
+    std::lock_guard<std::mutex> lock(renderRecordMutex_);
+    ConfirmUnlockState(formRenderWant);
+    auto search = renderRecordMap_.find(uid);
+    if (search != renderRecordMap_.end()) {
+        result = search->second->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
+    } else {
+        auto record = FormRenderRecord::Create(formJsInfo.bundleName, uid, formJsInfo.isDynamic, formSupplyClient);
+        if (record == nullptr) {
+            HILOG_ERROR("null record");
+            return RENDER_FORM_FAILED;
+        }
+
+        record->SetConfiguration(configuration_);
+        result = record->UpdateRenderRecord(formJsInfo, formRenderWant, hostToken);
+        if (renderRecordMap_.empty()) {
+            FormMemmgrClient::GetInstance().SetCritical(true);
+        }
+        renderRecordMap_.emplace(uid, record);
+        FormRenderGCTask(uid);
+    }
+    return result;
+}
+
+void FormRenderImpl::GetRenderRecordById(std::shared_ptr<FormRenderRecord>& search, const std::string& uid)
+{
+    std::lock_guard<std::mutex> lock(renderRecordMutex_);
+    auto iterator = renderRecordMap_.find(uid);
+    if (iterator == renderRecordMap_.end() || !(iterator->second)) {
+        HILOG_ERROR("fail");
+        return;
+    }
+    search = iterator->second;
+}
+
+int32_t FormRenderImpl::RecoverFormByUid(const FormJsInfo &formJsInfo, const Want &want, const std::string& uid,
+                                         const std::string& statusData)
+{
+    bool isRecoverFormToHandleClickEvent = want.GetBoolParam(
+        Constants::FORM_IS_RECOVER_FORM_TO_HANDLE_CLICK_EVENT, false);
+    std::lock_guard<std::mutex> lock(renderRecordMutex_);
+    if (auto search = renderRecordMap_.find(uid); search != renderRecordMap_.end()) {
+        if (search->second == nullptr) {
+            HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formJsInfo.formId).c_str());
+            return RECYCLE_FORM_FAILED;
+        }
+        return search->second->RecoverForm(formJsInfo, statusData, isRecoverFormToHandleClickEvent);
+    }
+    HILOG_ERROR("can't find render record of %{public}s", std::to_string(formJsInfo.formId).c_str());
+    return RENDER_FORM_FAILED;
+}
+
+int32_t FormRenderImpl::RecycleFormByUid(const std::string& uid, std::string& statusData, const int64_t formId)
+{
+    std::lock_guard<std::mutex> lock(renderRecordMutex_);
+    auto search = renderRecordMap_.find(uid);
+    if (search != renderRecordMap_.end()) {
+        if (search->second == nullptr) {
+            HILOG_ERROR("null renderRecord of %{public}s", std::to_string(formId).c_str());
+            return RECYCLE_FORM_FAILED;
+        }
+        auto ret = search->second->RecycleForm(formId, statusData);
+        if (ret != ERR_OK) {
+            return ret;
+        }
+    } else {
+        HILOG_ERROR("can't find render record of %{public}s", std::to_string(formId).c_str());
+        return RECYCLE_FORM_FAILED;
+    }
+    if (statusData.empty()) {
+        HILOG_WARN("empty statusData of %{public}s", std::to_string(formId).c_str());
+    }
+    return ERR_OK;
+}
+
+int32_t FormRenderImpl::DeleteRenderRecordByUid(const std::string& uid, const std::shared_ptr<FormRenderRecord>& search)
+{
+    if (!search) {
+        HILOG_ERROR("get render record fail");
+        return RENDER_FORM_FAILED;
+    }
+    std::lock_guard<std::mutex> lock(renderRecordMutex_);
+    if (search->IsEmpty() && !search->HasRenderFormTask()) {
+        auto iterator = renderRecordMap_.find(uid);
+        if (iterator == renderRecordMap_.end()) {
+            HILOG_ERROR("fail.");
+            return RENDER_FORM_FAILED;
+        }
+        renderRecordMap_.erase(iterator);
+        HILOG_INFO("DeleteRenderRecord success,uid:%{public}s", uid.c_str());
+        if (renderRecordMap_.empty()) {
+            FormMemmgrClient::GetInstance().SetCritical(false);
+        }
+    }
+    return ERR_OK;
+}
 } // namespace FormRender
 } // namespace AppExecFwk
 } // namespace OHOS
diff --git a/services/form_render_service/src/form_render_record.cpp b/services/form_render_service/src/form_render_record.cpp
index 0ac827cb3de69c8d7d4945afce09e8e73e9f0af7..de2c8f0b6a3b7feb699fa8a5ae3a37b8b82a5812 100644
--- a/services/form_render_service/src/form_render_record.cpp
+++ b/services/form_render_service/src/form_render_record.cpp
@@ -132,12 +132,7 @@ FormRenderRecord::FormRenderRecord(
 FormRenderRecord::~FormRenderRecord()
 {
     HILOG_INFO("call");
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
-
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_WARN("null eventHandler");
         return;
@@ -175,12 +170,7 @@ bool FormRenderRecord::HandleHostDied(const sptr<IRemoteObject> hostRemoteObj)
 
 void FormRenderRecord::DeleteRendererGroup(int64_t formId)
 {
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
-
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler");
         return;
@@ -271,11 +261,7 @@ void FormRenderRecord::AddWatchDogThreadMonitor()
 
 void FormRenderRecord::OnRenderingBlock(const std::string &bundleName)
 {
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
-    }
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
 
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient");
@@ -287,11 +273,7 @@ void FormRenderRecord::OnRenderingBlock(const std::string &bundleName)
 
 void FormRenderRecord::OnNotifyRefreshForm(const int64_t &formId)
 {
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
-    }
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
 
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient");
@@ -315,12 +297,10 @@ void FormRenderRecord::Timer()
 
 TaskState FormRenderRecord::RunTask()
 {
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        if (eventHandler_ == nullptr) {
-            HILOG_DEBUG("null eventHandler when bundleName %{public}s", bundleName_.c_str());
-            return TaskState::NO_RUNNING;
-        }
+    auto eventHandler = GetEventHandler();
+    if (eventHandler == nullptr) {
+        HILOG_DEBUG("null eventHandler when bundleName %{public}s", bundleName_.c_str());
+        return TaskState::NO_RUNNING;
     }
 
     std::unique_lock<std::mutex> lock(watchDogMutex_);
@@ -344,15 +324,12 @@ TaskState FormRenderRecord::RunTask()
         renderRecord->MarkThreadAlive();
     };
 
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        if (eventHandler_ == nullptr) {
-            return TaskState::NO_RUNNING;
-        }
+    if (eventHandler == nullptr) {
+        return TaskState::NO_RUNNING;
+    }
 
-        if (!eventHandler_->PostTask(checkTask, "Watchdog Task", 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) {
-            HILOG_ERROR("Watchdog checkTask postTask false");
-        }
+    if (!eventHandler->PostTask(checkTask, "Watchdog Task", 0, AppExecFwk::EventQueue::Priority::IMMEDIATE)) {
+        HILOG_ERROR("Watchdog checkTask postTask false");
     }
 
     return TaskState::RUNNING;
@@ -360,13 +337,13 @@ TaskState FormRenderRecord::RunTask()
 
 void FormRenderRecord::DumpEventHandler()
 {
-    std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-    if (eventHandler_ == nullptr) {
+    auto eventHandler = GetEventHandler();
+    if (eventHandler == nullptr) {
         return;
     }
 
     HandlerDumper handlerDumper;
-    eventHandler_->Dump(handlerDumper);
+    eventHandler->Dump(handlerDumper);
 }
 
 void FormRenderRecord::MarkThreadAlive()
@@ -402,17 +379,13 @@ int32_t FormRenderRecord::UpdateRenderRecord(const FormJsInfo &formJsInfo, const
     }
     {
         // Some resources need to be initialized in a JS thread
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
+        std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
         if (!CheckEventHandler(true, formJsInfo.isDynamic)) {
             HILOG_ERROR("null eventHandler_ ");
             return RENDER_FORM_FAILED;
         }
 
-        sptr<IFormSupply> formSupplyClient = nullptr;
-        {
-            std::lock_guard<std::mutex> lock(formSupplyMutex_);
-            formSupplyClient = formSupplyClient_;
-        }
+        sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
         if (formSupplyClient == nullptr) {
             HILOG_ERROR("null formSupplyClient");
             return RENDER_FORM_FAILED;
@@ -430,21 +403,18 @@ int32_t FormRenderRecord::UpdateRenderRecord(const FormJsInfo &formJsInfo, const
             formSupplyClient->OnRenderFormDone(formJsInfo.formId);
             renderRecord->MarkRenderFormTaskDone(renderType);
         };
-        eventHandler_->PostTask(task, "UpdateRenderRecord");
+        if (eventHandler == nullptr) {
+            HILOG_ERROR("null eventHandler_ ");
+            return RENDER_FORM_FAILED;
+        }
+        eventHandler->PostTask(task, "UpdateRenderRecord");
     }
 
     if (hostRemoteObj == nullptr) {
         HILOG_WARN("null hostRemoteObj");
         return RENDER_FORM_FAILED;
     }
-    std::lock_guard<std::mutex> lock(hostsMapMutex_);
-    auto iter = hostsMapForFormId_.find(formJsInfo.formId);
-    if (iter == hostsMapForFormId_.end()) {
-        hostsMapForFormId_.emplace(formJsInfo.formId, IRemoteObjectSet({ hostRemoteObj }));
-        return ERR_OK;
-    }
-    iter->second.emplace(hostRemoteObj);
-    return ERR_OK;
+    return AddHostByFormId(formJsInfo.formId, hostRemoteObj);
 }
 
 void FormRenderRecord::DeleteRenderRecord(int64_t formId, const std::string &compId,
@@ -452,12 +422,7 @@ void FormRenderRecord::DeleteRenderRecord(int64_t formId, const std::string &com
 {
     // Some resources need to be deleted in a JS thread
     HILOG_INFO("Delete some resources formId:%{public}" PRId64 ",%{public}s", formId, compId.c_str());
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
-
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler");
         DeleteFormRequest(formId, compId);
@@ -477,14 +442,12 @@ void FormRenderRecord::DeleteRenderRecord(int64_t formId, const std::string &com
     };
 
     if (hostRemoteObj != nullptr) {
-        std::lock_guard<std::mutex> lock(hostsMapMutex_);
-        auto iter = hostsMapForFormId_.find(formId);
-        if (iter != hostsMapForFormId_.end()) {
-            std::unordered_set<sptr<IRemoteObject>, RemoteObjHash> &hosts = iter->second;
-            hosts.erase(hostRemoteObj);
-        }
+        DeleteHostRemoteObjByFormId(formId, hostRemoteObj);
+    }
+    if (eventHandler == nullptr) {
+        return;
     }
-    eventHandler_->PostSyncTask(task, "DeleteRenderRecord");
+    eventHandler->PostSyncTask(task, "DeleteRenderRecord");
 }
 
 bool FormRenderRecord::IsEmpty()
@@ -544,12 +507,9 @@ bool FormRenderRecord::CreateRuntime(const FormJsInfo &formJsInfo)
 
 bool FormRenderRecord::UpdateRuntime(const FormJsInfo &formJsInfo)
 {
-    {
-        std::lock_guard<std::mutex> lock(contextsMapMutex_);
-        auto moduleInfo = contextsMapForModuleName_.find(GenerateContextKey(formJsInfo));
-        if (moduleInfo != contextsMapForModuleName_.end()) {
-            return false;
-        }
+    if (IsFormContextExist(formJsInfo)) {
+        HILOG_WARN("context is exist. %{public}s", formJsInfo.bundleName.c_str());
+        return false;
     }
     if (!runtime_) {
         HILOG_ERROR("runtime is not exist. %{public}s", formJsInfo.bundleName.c_str());
@@ -694,12 +654,10 @@ std::shared_ptr<Ace::FormRendererGroup> FormRenderRecord::GetFormRendererGroup(c
     const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<AbilityRuntime::Runtime> &runtime)
 {
     HILOG_INFO("Get formRendererGroup");
-    {
-        std::shared_lock<std::shared_mutex> lock(eventHandlerReset_);
-            if (eventHandleNeedReset) {
-            return nullptr;
-        }
+    if (GetEventHandlerNeedReset()) {
+        return nullptr;
     }
+    std::lock_guard<std::mutex> lock(formRendererGroupMutex_);
     auto key = formJsInfo.formId;
     auto iter = formRendererGroupMap_.find(key);
     if (iter != formRendererGroupMap_.end()) {
@@ -718,13 +676,11 @@ std::shared_ptr<Ace::FormRendererGroup> FormRenderRecord::CreateFormRendererGrou
     const std::shared_ptr<AbilityRuntime::Context> &context, const std::shared_ptr<AbilityRuntime::Runtime> &runtime)
 {
     HILOG_INFO("Create formRendererGroup");
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        if (eventHandler_ == nullptr) {
-            return nullptr;
-        }
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
+    if (eventHandler == nullptr) {
+        return nullptr;
     }
-    auto formRendererGroup = Ace::FormRendererGroup::Create(context, runtime, eventHandler_);
+    auto formRendererGroup = Ace::FormRendererGroup::Create(context, runtime, eventHandler);
     if (formRendererGroup == nullptr) {
         HILOG_ERROR("Create formRendererGroup failed");
         return nullptr;
@@ -770,15 +726,9 @@ void FormRenderRecord::HandleUpdateForm(const FormJsInfo &formJsInfo, const Want
     }
 
     std::unordered_map<std::string, Ace::FormRequest> formRequests;
-    {
-        std::lock_guard<std::mutex> lock(formRequestsMutex_);
-        auto iter = formRequests_.find(formJsInfo.formId);
-        if (iter == formRequests_.end()) {
-            OnNotifyRefreshForm(formJsInfo.formId);
-            return;
-        }
-
-        formRequests = iter->second;
+    if (!GetFormRequestByFormId(formJsInfo.formId, formRequests)) {
+        OnNotifyRefreshForm(formJsInfo.formId);
+        return;
     }
     std::string compMaxId = "0";
     for (const auto& iter : formRequests) {
@@ -838,7 +788,6 @@ void FormRenderRecord::AddRenderer(const FormJsInfo &formJsInfo, const Want &wan
         return;
     }
 
-    std::lock_guard<std::mutex> lock(formRendererGroupMutex_);
     auto formRendererGroup = GetFormRendererGroup(formJsInfo, context, runtime_);
     if (formRendererGroup == nullptr) {
         HILOG_ERROR("Create formRendererGroup failed");
@@ -884,8 +833,7 @@ bool FormRenderRecord::HandleDeleteInJsThread(int64_t formId, const std::string
         search->second->DeleteForm();
         formRendererGroupMap_.erase(formId);
     }
-    std::lock_guard<std::mutex> lock(hostsMapMutex_);
-    hostsMapForFormId_.erase(formId);
+    RemoveHostByFormId(formId);
     return true;
 }
 
@@ -1005,8 +953,7 @@ void FormRenderRecord::DeleteFormRequest(int64_t formId, const std::string &comp
         }
     }
     if (isRequestEmpty) {
-        std::lock_guard<std::mutex> lock(recycledFormCompIdsMutex_);
-        recycledFormCompIds_.erase(formId);
+        DeleteRecycledFormCompIds(formId);
     }
     HILOG_INFO("delete request formId:%{public}" PRId64 " compId:%{public}s request empty:%{public}d",
         formId, compId.c_str(), isRequestEmpty);
@@ -1040,12 +987,7 @@ void FormRenderRecord::ReleaseRenderer(
 {
     HILOG_INFO("Release renderer which formId:%{public}s, compId:%{public}s start.",
         std::to_string(formId).c_str(), compId.c_str());
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
-
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler");
         return;
@@ -1099,11 +1041,8 @@ bool FormRenderRecord::HandleReleaseRendererInJsThread(
         formRendererGroupMap_.erase(formId);
         isRenderGroupEmpty = formRendererGroupMap_.empty();
     }
-    {
-        std::lock_guard<std::mutex> lock(recycledFormCompIdsMutex_);
-        recycledFormCompIds_.erase(formId);
-        recycledFormCompIds_.emplace(formId, compIds);
-    }
+    DeleteRecycledFormCompIds(formId);
+    InsertRecycledFormCompIds(formId, compIds);
     return true;
 }
 
@@ -1214,13 +1153,11 @@ void FormRenderRecord::ReAddRecycledForms(const std::vector<FormJsInfo> &formJsI
     for (const auto &form : formJsInfos) {
         auto iter = formRequests_.find(form.formId);
         if (iter == formRequests_.end()) {
-            HILOG_ERROR("%{public}" PRId64 " formRequest is empty", form.formId);
             continue;
         }
 
         for (const auto& formRequest : iter->second) {
             if (!formRequest.second.hasRelease) {
-                HILOG_ERROR("%{public}" PRId64 " hasRelease false", form.formId);
                 continue;
             }
 
@@ -1269,11 +1206,7 @@ inline std::string FormRenderRecord::GenerateContextKey(const FormJsInfo &formJs
 int32_t FormRenderRecord::ReloadFormRecord(const std::vector<FormJsInfo> &&formJsInfos, const Want &want)
 {
     HILOG_INFO("Reload form record");
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         if (!CheckEventHandler(true, true)) {
             HILOG_ERROR("null eventHandler");
@@ -1305,11 +1238,7 @@ int32_t FormRenderRecord::ReloadFormRecord(const std::vector<FormJsInfo> &&formJ
 
 bool FormRenderRecord::ReAddIfHapPathChanged(const std::vector<FormJsInfo> &formJsInfos)
 {
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler");
         return false;
@@ -1324,19 +1253,11 @@ bool FormRenderRecord::ReAddIfHapPathChanged(const std::vector<FormJsInfo> &form
         FormMemoryGuard memoryGuard;
         renderRecord->HandleReleaseAllRendererInJsThread();
     };
-    {
-        std::lock_guard<std::shared_mutex> lock(eventHandlerReset_);
-        HILOG_INFO("eventHandleNeedReset, reject create renderergroup");
-        eventHandleNeedReset = true;
-    }
+    SetEventHandlerNeedResetFlag(true);
     eventHandler->PostSyncTask(task, "ReleaseAllRenderer");
     Release();
     UpdateAllFormRequest(formJsInfos, true);
-    {
-        std::lock_guard<std::shared_mutex> lock(eventHandlerReset_);
-        HILOG_INFO("eventHandleNeedReset, Create new eventHandler");
-        eventHandleNeedReset = false;
-    }
+    SetEventHandlerNeedResetFlag(false);
     {
         std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
         CreateEventHandler(bundleName_, true);
@@ -1358,11 +1279,8 @@ void FormRenderRecord::HandleReleaseAllRendererInJsThread()
         HILOG_INFO("Release renderer which formId:%{public}" PRId64, formId);
         std::pair<std::vector<std::string>, std::string> compIds = iter.second->GetOrderedAndCurrentCompIds();
         iter.second->DeleteForm();
-        {
-            std::lock_guard<std::mutex> lock(recycledFormCompIdsMutex_);
-            recycledFormCompIds_.erase(formId);
-            recycledFormCompIds_.emplace(formId, compIds);
-        }
+        DeleteRecycledFormCompIds(formId);
+        InsertRecycledFormCompIds(formId, compIds);
     }
     formRendererGroupMap_.clear();
 }
@@ -1398,12 +1316,12 @@ int32_t FormRenderRecord::OnUnlock()
         }
         renderRecord->HandleOnUnlock();
     };
-    std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-    if (eventHandler_ == nullptr) {
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
+    if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler_");
         return RENDER_FORM_FAILED;
     }
-    eventHandler_->PostTask(task, "OnUnlock");
+    eventHandler->PostTask(task, "OnUnlock");
     return ERR_OK;
 }
 
@@ -1430,11 +1348,7 @@ int32_t FormRenderRecord::HandleOnUnlock()
 int32_t FormRenderRecord::SetVisibleChange(const int64_t &formId, bool isVisible)
 {
     HILOG_INFO("SetVisibleChange, formId:%{public}s", std::to_string(formId).c_str());
-    std::shared_ptr<EventHandler> eventHandler = nullptr;
-    {
-        std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
-        eventHandler = eventHandler_;
-    }
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (eventHandler == nullptr) {
         HILOG_ERROR("null eventHandler");
         return SET_VISIBLE_CHANGE_FAILED;
@@ -1449,7 +1363,7 @@ int32_t FormRenderRecord::SetVisibleChange(const int64_t &formId, bool isVisible
         renderRecord->HandleSetVisibleChange(formId, isVisible);
     };
 
-    eventHandler->PostSyncTask(task, "SetVisibleChange");
+    eventHandler->PostTask(task, "SetVisibleChange");
     return ERR_OK;
 }
 
@@ -1641,17 +1555,13 @@ int32_t FormRenderRecord::RecoverForm(const FormJsInfo &formJsInfo,
 {
     auto formId = formJsInfo.formId;
     HILOG_INFO("RecoverForm begin, formId:%{public}s", std::to_string(formId).c_str());
-    std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
+    std::shared_ptr<EventHandler> eventHandler = GetEventHandler();
     if (!CheckEventHandler(true, true)) {
         HILOG_ERROR("null eventHandler_");
         return RENDER_FORM_FAILED;
     }
 
-    sptr<IFormSupply> formSupplyClient = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formSupplyMutex_);
-        formSupplyClient = formSupplyClient_;
-    }
+    sptr<IFormSupply> formSupplyClient = GetFormSupplyClient();
     if (formSupplyClient == nullptr) {
         HILOG_ERROR("null formSupplyClient");
         return RENDER_FORM_FAILED;
@@ -1667,7 +1577,11 @@ int32_t FormRenderRecord::RecoverForm(const FormJsInfo &formJsInfo,
         renderRecord->HandleRecoverForm(formJsInfo, statusData, isRecoverFormToHandleClickEvent);
         formSupplyClient->OnRecoverFormDone(formJsInfo.formId);
     };
-    eventHandler_->PostTask(task, "RecoverForm");
+    if (eventHandler == nullptr) {
+        HILOG_ERROR("null eventHandler_ ");
+        return RENDER_FORM_FAILED;
+    }
+    eventHandler->PostTask(task, "RecoverForm");
     return ERR_OK;
 }
 
@@ -1678,14 +1592,9 @@ void FormRenderRecord::HandleRecoverForm(const FormJsInfo &formJsInfo,
     HILOG_INFO("HandleRecoverForm begin, formId:%{public}s, uid:%{public}s", std::to_string(formId).c_str(),
         uid_.c_str());
     std::unordered_map<std::string, Ace::FormRequest> formRequests;
-    {
-        std::lock_guard<std::mutex> lock(formRequestsMutex_);
-        auto iter = formRequests_.find(formId);
-        if (iter == formRequests_.end()) {
-            HILOG_ERROR("%{public}s doesn't has formRequest", std::to_string(formId).c_str());
-            return;
-        }
-        formRequests = iter->second;
+    if (!GetFormRequestByFormId(formId, formRequests)) {
+        HILOG_ERROR("not find formRequests");
+        return;
     }
     if (formRequests.empty()) {
         HILOG_ERROR("empty formRequests");
@@ -1730,13 +1639,18 @@ bool FormRenderRecord::RecoverFormRequestsInGroup(const FormJsInfo &formJsInfo,
     std::string currentCompId;
     bool flag = GetAndDeleteRecycledCompIds(formId, orderedCompIds, currentCompId);
     if (!flag) {
-        HILOG_INFO("init compIds failed,formId:%{public}" PRId64, formId);
+        HILOG_ERROR("init compIds failed,formId:%{public}" PRId64, formId);
         return false;
     }
     
     std::vector<Ace::FormRequest> groupRequests;
     size_t currentRequestIndex = 0;
     bool currentRequestFound = false;
+    if (!GetFormRequestByFormId(formId, recordFormRequests)) {
+        HILOG_ERROR("find formRequest failed,formId:%{public}" PRId64, formId);
+        return false;
+    }
+
     UpdateGroupRequestsWhenRecover(formId, formJsInfo, orderedCompIds, currentCompId, statusData, isHandleClickEvent,
         currentRequestIndex, groupRequests, currentRequestFound, recordFormRequests);
 
@@ -1814,13 +1728,16 @@ bool FormRenderRecord::RecoverRenderer(const std::vector<Ace::FormRequest> &grou
         return false;
     }
 
-    std::lock_guard<std::mutex> lock(formRendererGroupMutex_);
     auto formRendererGroup = GetFormRendererGroup(currentRequest.formJsInfo, context, runtime_);
     if (formRendererGroup == nullptr) {
         HILOG_ERROR("Create formRendererGroup failed");
         return false;
     }
-    formRendererGroup->RecoverRenderer(groupRequests, currentRequestIndex);
+    auto task = [formRendererGroup, groupRequests, currentRequestIndex]() {
+        HILOG_INFO("execute recover form task");
+        formRendererGroup->RecoverRenderer(groupRequests, currentRequestIndex);
+    };
+    eventHandler_->PostTask(task, "RecoverRenderer");
     HILOG_INFO("recover renderer, formId:%{public}" PRId64, currentRequest.formJsInfo.formId);
     return true;
 }
@@ -1886,6 +1803,101 @@ bool FormRenderRecord::CheckManagerDelegateValid(const FormJsInfo &formJsInfo, c
 
     return iter->second->IsManagerDelegateValid(want);
 }
+
+void FormRenderRecord::SetFormSupplyClient(const sptr<IFormSupply>& formSupplyClient)
+{
+    std::lock_guard<std::mutex> lock(formSupplyMutex_);
+    formSupplyClient_ = formSupplyClient;
+}
+
+sptr<IFormSupply> FormRenderRecord::GetFormSupplyClient()
+{
+    std::lock_guard<std::mutex> lock(formSupplyMutex_);
+    return formSupplyClient_;
+}
+
+std::shared_ptr<EventHandler> FormRenderRecord::GetEventHandler()
+{
+    std::lock_guard<std::recursive_mutex> lock(eventHandlerMutex_);
+    return eventHandler_;
+}
+
+int32_t FormRenderRecord::AddHostByFormId(int64_t formId, const sptr<IRemoteObject> hostRemoteObj)
+{
+    std::lock_guard<std::mutex> lock(hostsMapMutex_);
+    auto iter = hostsMapForFormId_.find(formId);
+    if (iter == hostsMapForFormId_.end()) {
+        hostsMapForFormId_.emplace(formId, IRemoteObjectSet({ hostRemoteObj }));
+        return ERR_OK;
+    }
+    iter->second.emplace(hostRemoteObj);
+    return ERR_OK;
+}
+
+void FormRenderRecord::DeleteHostRemoteObjByFormId(int64_t formId, const sptr<IRemoteObject> hostRemoteObj)
+{
+    std::lock_guard<std::mutex> lock(hostsMapMutex_);
+    auto iter = hostsMapForFormId_.find(formId);
+    if (iter != hostsMapForFormId_.end()) {
+        std::unordered_set<sptr<IRemoteObject>, RemoteObjHash> &hosts = iter->second;
+        hosts.erase(hostRemoteObj);
+    }
+}
+
+void FormRenderRecord::RemoveHostByFormId(int64_t formId)
+{
+    std::lock_guard<std::mutex> lock(hostsMapMutex_);
+    hostsMapForFormId_.erase(formId);
+}
+
+bool FormRenderRecord::IsFormContextExist(const FormJsInfo &formJsInfo)
+{
+    std::lock_guard<std::mutex> lock(contextsMapMutex_);
+    auto moduleInfo = contextsMapForModuleName_.find(GenerateContextKey(formJsInfo));
+    return moduleInfo != contextsMapForModuleName_.end();
+}
+
+bool FormRenderRecord::GetFormRequestByFormId(int64_t formId,
+    std::unordered_map<std::string, Ace::FormRequest>& formRequests)
+{
+    std::lock_guard<std::mutex> lock(formRequestsMutex_);
+    auto iter = formRequests_.find(formId);
+    if (iter == formRequests_.end()) {
+        HILOG_WARN("not find form request,formId:%{public}" PRId64, formId);
+        return false;
+    }
+
+    formRequests = iter->second;
+    return true;
+}
+
+void FormRenderRecord::SetEventHandlerNeedResetFlag(bool needReset)
+{
+    std::lock_guard<std::shared_mutex> lock(eventHandlerReset_);
+    HILOG_INFO("eventHandleNeedReset: %{public}d", needReset);
+    eventHandleNeedReset = needReset;
+}
+
+bool FormRenderRecord::GetEventHandlerNeedReset()
+{
+    std::lock_guard<std::shared_mutex> lock(eventHandlerReset_);
+    HILOG_INFO("eventHandleNeedReset: %{public}d", eventHandleNeedReset);
+    return eventHandleNeedReset;
+}
+
+void FormRenderRecord::DeleteRecycledFormCompIds(int64_t formId)
+{
+    std::lock_guard<std::mutex> lock(recycledFormCompIdsMutex_);
+    recycledFormCompIds_.erase(formId);
+}
+
+void FormRenderRecord::InsertRecycledFormCompIds(int64_t formId,
+    const std::pair<std::vector<std::string>, std::string>& compIds)
+{
+    std::lock_guard<std::mutex> lock(recycledFormCompIdsMutex_);
+    recycledFormCompIds_.emplace(formId, compIds);
+}
+
 } // namespace FormRender
 } // namespace AppExecFwk
-} // namespace OHOS
+} // namespace OHOS
\ No newline at end of file
diff --git a/services/include/data_center/database/form_db_cache.h b/services/include/data_center/database/form_db_cache.h
index a2079ed06d1059b786ca61974d263474e1ea4c06..a47a9ed4085690e3d53d2b1101c1276870c5a7d4 100644
--- a/services/include/data_center/database/form_db_cache.h
+++ b/services/include/data_center/database/form_db_cache.h
@@ -46,6 +46,20 @@ public:
      */
     void GetAllFormInfo(std::vector<FormDBInfo> &formDBInfos);
 
+    /**
+     * @brief Get all form data size from DbCache.
+     * @return Returns form data size.
+     */
+    int32_t GetAllFormInfoSize();
+
+    /**
+     * @brief Get form counts from DbCache by calling user id.
+     * @param currentAccountId current account ID.
+     * @param callingUid calling user ID.
+     * @return Returns form counts.
+     */
+    int GetFormCountsByCallingUid(const int32_t currentAccountId, const int callingUid);
+
     /**
      * @brief Get all form data in DbCache and DB by bundleName.
      * @param bundleName BundleName.
diff --git a/services/include/data_center/form_data_mgr.h b/services/include/data_center/form_data_mgr.h
index a74740b80eb053c85d0aacd004e2f89fd56f6456..8fda705da0fc7523600535ec52c973acfb705293 100644
--- a/services/include/data_center/form_data_mgr.h
+++ b/services/include/data_center/form_data_mgr.h
@@ -633,6 +633,12 @@ public:
     */
     int32_t GetCastFormsCount(int32_t &formCount);
 
+    /**
+    * @brief get temp forms count.
+    * @return Return the temp forms number.
+    */
+    int32_t GetTempFormCount() const;
+
     /**
     * @brief get temp forms count.
     * @param formCount Returns the number of the temp form.
@@ -903,6 +909,14 @@ public:
      */
     void GetFormRecordsByUserId(const int32_t userId, std::vector<FormRecord> &formRecords);
 
+    /**
+     * @brief get formRecord by formId
+     * @param formId form id.
+     * @param formRecord form record.
+     * @return Returns true on success, false on failure.
+     */
+    bool GetFormRecordById(const int64_t formId, FormRecord& formRecord);
+
 private:
     /**
      * @brief Create form record.
diff --git a/services/include/data_center/form_data_proxy_mgr.h b/services/include/data_center/form_data_proxy_mgr.h
index 0c5e5b9a927312b2b33088ecdaf53cc1ccf35c32..59a89d879948393e996a03f644fd226d23427f3e 100644
--- a/services/include/data_center/form_data_proxy_mgr.h
+++ b/services/include/data_center/form_data_proxy_mgr.h
@@ -43,6 +43,10 @@ public:
     // will run only once
     void RetryFailureSubscribes();
     void GetFormSubscribeInfo(const int64_t formId, std::vector<std::string> &subscribedKeys, int32_t &count);
+
+private:
+    void UnsubscribeFormDataById(int64_t formId);
+
 private:
     std::mutex formDataProxyRecordMutex_;
     std::map<int64_t, std::shared_ptr<FormDataProxyRecord>> formDataProxyRecordMap_; // formId:FormDataProxyRecord
diff --git a/services/include/form_mgr/form_mgr_adapter.h b/services/include/form_mgr/form_mgr_adapter.h
index 81d1963f24e377b017e8881d51ef5a551353328a..eb4408ff255e1703435a391122afadd65dffe54a 100644
--- a/services/include/form_mgr/form_mgr_adapter.h
+++ b/services/include/form_mgr/form_mgr_adapter.h
@@ -1182,6 +1182,8 @@ private:
 
     void CancelAddFormRequestTimeOutTask(const int64_t formId, const int result);
 
+    AddFormResultErrorCode GetFormResultErrCode(const int64_t formId);
+
     ErrCode CheckAddFormTaskTimeoutOrFailed(const int64_t formId, AddFormResultErrorCode &formStates);
 
     void RemoveFormIdMapElement(const int64_t formId);
diff --git a/services/include/form_render/form_render_mgr_inner.h b/services/include/form_render/form_render_mgr_inner.h
index fc58d9381d3f1c2e07c0cb88d98971c69b682985..b510a9dd0c9b1082e4fa0b360f0f38b6c5a9285e 100644
--- a/services/include/form_render/form_render_mgr_inner.h
+++ b/services/include/form_render/form_render_mgr_inner.h
@@ -85,7 +85,7 @@ public:
 
     ErrCode RecoverForms(const std::vector<int64_t> &formIds, const WantParams &wantParams);
 
-    ErrCode UpdateFormSize(const int64_t &formId, float width, float height, float borderWidth);
+	ErrCode UpdateFormSize(const int64_t &formId, float width, float height, float borderWidth);
 
     void SetUserId(int32_t userId);
 
@@ -113,6 +113,18 @@ private:
 
     ErrCode GetRenderObject(sptr<IRemoteObject> &renderObj);
 
+    bool GetRenderFormConnectId(const int64_t formId, int32_t& connectId);
+
+    bool GetRenderFormConnection(sptr<FormRenderConnection>& connection, const int64_t formId);
+
+    void GetConnectedForms(const std::vector<int64_t> &formIds, std::vector<int64_t>& connectedForms);
+
+    ErrCode RenderConnectedForm(const FormRecord &formRecord, Want &want, const sptr<FormRenderConnection>& connection);
+
+    ErrCode PostStopRenderingFormTask(const FormRecord &formRecord, Want &want);
+
+    ErrCode CheckRenderConnectionExistById(int64_t formId);
+
 private:
     class RemoteObjHash {
     public:
diff --git a/services/src/data_center/database/form_db_cache.cpp b/services/src/data_center/database/form_db_cache.cpp
index 6e0717a362e437670826094e0b3ab3eb81e3a160..91d7348f57c12a88290e2b7a3a43cc6233416cc4 100644
--- a/services/src/data_center/database/form_db_cache.cpp
+++ b/services/src/data_center/database/form_db_cache.cpp
@@ -495,5 +495,39 @@ ErrCode FormDbCache::UpdateFormLocation(const int64_t formId, const int32_t form
     return ERR_APPEXECFWK_FORM_INVALID_FORM_ID;
 }
 
+/**
+ * @brief Get form counts from DbCache by calling user id.
+ * @param currentAccountId current account ID.
+ * @param callingUid calling user ID.
+ * @return Returns form counts.
+ */
+int FormDbCache::GetFormCountsByCallingUid(const int32_t currentAccountId, const int callingUid)
+{
+    int callingUidFormCounts = 0;
+    std::lock_guard<std::mutex> lock(formDBInfosMutex_);
+    for (const auto& record : formDBInfos_) {
+        if (record.providerUserId != currentAccountId) {
+            continue;
+        }
+        for (const auto &userUid : record.formUserUids) {
+            if (userUid != callingUid) {
+                continue;
+            }
+            callingUidFormCounts++;
+        }
+    }
+    return callingUidFormCounts;
+}
+
+/**
+ * @brief Get all form data size from DbCache.
+ * @return Returns form data size.
+ */
+int32_t FormDbCache::GetAllFormInfoSize()
+{
+    HILOG_INFO("call");
+    std::lock_guard<std::mutex> lock(formDBInfosMutex_);
+    return static_cast<int32_t>(formDBInfos_.size());
+}
 } // namespace AppExecFwk
 } // namespace OHOS
diff --git a/services/src/data_center/form_data_mgr.cpp b/services/src/data_center/form_data_mgr.cpp
index c307568869287fd20f48f51f23c1fdefbc2f720f..a6bec33e5e0e6860eb7ce74d3b321d2a251a7490 100644
--- a/services/src/data_center/form_data_mgr.cpp
+++ b/services/src/data_center/form_data_mgr.cpp
@@ -335,8 +335,7 @@ int FormDataMgr::CheckTempEnoughForm() const
         Constants::MAX_TEMP_FORMS : maxTempSize;
     HILOG_DEBUG("maxTempSize:%{public}d", maxTempSize);
 
-    std::lock_guard<std::mutex> lock(formTempMutex_);
-    if (static_cast<int32_t>(tempForms_.size()) >= maxTempSize) {
+    if (GetTempFormCount() >= maxTempSize) {
         HILOG_WARN("already exist %{public}d temp forms in system", maxTempSize);
         FormEventReport::SendFormFailedEvent(FormEventName::ADD_FORM_FAILED, HiSysEventType::FAULT,
             static_cast<int64_t>(AddFormFiledErrorType::NUMBER_EXCEEDING_LIMIT));
@@ -344,6 +343,7 @@ int FormDataMgr::CheckTempEnoughForm() const
     }
     return ERR_OK;
 }
+
 /**
  * @brief Check form count is max.
  * @param callingUid The UID of the proxy.
@@ -354,7 +354,6 @@ int FormDataMgr::CheckEnoughForm(const int callingUid, const int32_t currentUser
 {
     HILOG_INFO("callingUid:%{public}d, currentUserId:%{public}d", callingUid, currentUserId);
 
-    int callingUidFormCounts = 0;
     int32_t maxFormsSize = Constants::MAX_FORMS;
     GetConfigParamFormMap(Constants::MAX_NORMAL_FORM_SIZE, maxFormsSize);
     maxFormsSize = ((maxFormsSize > Constants::MAX_FORMS) || (maxFormsSize < 0)) ?
@@ -372,11 +371,9 @@ int FormDataMgr::CheckEnoughForm(const int callingUid, const int32_t currentUser
         return ERR_APPEXECFWK_FORM_MAX_FORMS_PER_CLIENT;
     }
 
-    std::lock_guard<std::mutex> lock(formRecordMutex_);
-    std::vector<FormDBInfo> formDbInfos;
-    FormDbCache::GetInstance().GetAllFormInfo(formDbInfos);
-    HILOG_INFO("already use %{public}zu forms by userId", formDbInfos.size());
-    if (static_cast<int32_t>(formDbInfos.size()) >= maxFormsSize) {
+    const auto formDbInfoSize = FormDbCache::GetInstance().GetAllFormInfoSize();
+    HILOG_INFO("already use %{public}d forms by userId", formDbInfoSize);
+    if (formDbInfoSize >= maxFormsSize) {
         HILOG_WARN("exceeds max form number %{public}d", maxFormsSize);
         FormEventReport::SendFormFailedEvent(FormEventName::ADD_FORM_FAILED, HiSysEventType::FAULT,
             static_cast<int64_t>(AddFormFiledErrorType::NUMBER_EXCEEDING_LIMIT));
@@ -384,24 +381,15 @@ int FormDataMgr::CheckEnoughForm(const int callingUid, const int32_t currentUser
     }
 
     int32_t currentAccountId = FormUtil::GetCurrentAccountId();
-    for (const auto &record : formDbInfos) {
-        if ((record.providerUserId == currentAccountId)) {
-            HILOG_DEBUG("called by currentActiveUser");
-            for (const auto &userUid : record.formUserUids) {
-                if (userUid != callingUid) {
-                    continue;
-                }
-                if (++callingUidFormCounts >= maxRecordPerApp) {
-                    HILOG_WARN("already use %{public}d forms by userId==currentAccountId", maxRecordPerApp);
-                    return ERR_APPEXECFWK_FORM_MAX_FORMS_PER_CLIENT;
-                }
-                break;
-            }
-        }
+    int callingUidFormCounts = FormDbCache::GetInstance().GetFormCountsByCallingUid(currentAccountId, callingUid);
+    if (callingUidFormCounts >= maxRecordPerApp) {
+        HILOG_WARN("already use %{public}d forms by userId==currentAccountId", maxRecordPerApp);
+        return ERR_APPEXECFWK_FORM_MAX_FORMS_PER_CLIENT;
     }
 
     return ERR_OK;
 }
+
 /**
  * @brief Delete temp form.
  * @param formId The Id of the form.
@@ -2433,21 +2421,14 @@ ErrCode FormDataMgr::GetFormInstancesByFilter(const FormInstancesFilter &formIns
 ErrCode FormDataMgr::GetFormInstanceById(const int64_t formId, FormInstance &formInstance)
 {
     HILOG_DEBUG("get form instance by formId");
-    bool isFormRecordsEnd = false;
-    FormRecord formRecord;
-    {
-        std::lock_guard<std::mutex> lock(formRecordMutex_);
-        if (formId <= 0) {
-            HILOG_ERROR("invalid formId");
-            return ERR_APPEXECFWK_FORM_INVALID_PARAM;
-        }
-        auto info = formRecords_.find(formId);
-        isFormRecordsEnd = info == formRecords_.end();
-        if (!isFormRecordsEnd) {
-            formRecord = info->second;
-        }
+    bool notFindFormRecord  = false;
+    if (formId <= 0) {
+        HILOG_ERROR("invalid formId");
+        return ERR_APPEXECFWK_FORM_INVALID_PARAM;
     }
-    if (!isFormRecordsEnd) {
+    FormRecord formRecord;
+    notFindFormRecord  = GetFormRecordById(formId, formRecord);
+    if (!notFindFormRecord ) {
         std::vector<FormHostRecord> formHostRecords;
         GetFormHostRecord(formId, formHostRecords);
         if (formHostRecords.empty()) {
@@ -2508,17 +2489,9 @@ ErrCode FormDataMgr::GetFormInstanceById(const int64_t formId, bool isUnusedIncl
         HILOG_ERROR("invalid formId");
         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
     }
-    bool isFormRecordsEnd = false;
     FormRecord formRecord;
     std::vector<FormHostRecord> formHostRecords;
-    {
-        std::lock_guard<std::mutex> lock(formRecordMutex_);
-        auto info = formRecords_.find(formId);
-        isFormRecordsEnd = info == formRecords_.end();
-        if (!isFormRecordsEnd) {
-            formRecord = info->second;
-        }
-    }
+    bool isFormRecordsEnd = GetFormRecordById(formId, formRecord);
     if (!isFormRecordsEnd) {
         GetFormHostRecord(formId, formHostRecords);
     }
@@ -2985,5 +2958,33 @@ void FormDataMgr::GetFormRecordsByUserId(const int32_t userId, std::vector<FormR
     }
     HILOG_INFO("userId:%{public}d, size:%{public}zu", userId, formRecords.size());
 }
+
+/**
+ * @brief get temp forms count.
+ * @return Return the temp forms number.
+ */
+int32_t FormDataMgr::GetTempFormCount() const
+{
+    std::lock_guard<std::mutex> lock(formTempMutex_);
+    return static_cast<int32_t>(tempForms_.size());
+}
+
+/**
+ * @brief get formRecord by formId
+ * @param formId form id.
+ * @param formRecord form record.
+ * @return Returns true on success, false on failure.
+ */
+bool FormDataMgr::GetFormRecordById(const int64_t formId, FormRecord& formRecord)
+{
+    bool notFindFormRecord  = false;
+    std::lock_guard<std::mutex> lock(formRecordMutex_);
+    auto info = formRecords_.find(formId);
+    notFindFormRecord  = info == formRecords_.end();
+    if (!notFindFormRecord ) {
+        formRecord = info->second;
+    }
+    return notFindFormRecord ;
+}
 }  // namespace AppExecFwk
 }  // namespace OHOS
diff --git a/services/src/data_center/form_data_proxy_mgr.cpp b/services/src/data_center/form_data_proxy_mgr.cpp
index c7aedfb48d2f09e729785c0c758eb7f47ec7796b..6ead426dbbcc2948474dcfab87c85d2284ac14a5 100644
--- a/services/src/data_center/form_data_proxy_mgr.cpp
+++ b/services/src/data_center/form_data_proxy_mgr.cpp
@@ -51,16 +51,7 @@ ErrCode FormDataProxyMgr::SubscribeFormData(int64_t formId, const std::vector<Fo
         return ERR_OK;
     }
 
-    {
-        std::lock_guard<std::mutex> lock(formDataProxyRecordMutex_);
-        auto search = formDataProxyRecordMap_.find(formId);
-        if (search != formDataProxyRecordMap_.end()) {
-            if (search->second != nullptr) {
-                HILOG_INFO("the form has already subscribed, formId:%{public}" PRId64, formId);
-                search->second->UnsubscribeFormData();
-            }
-        }
-    }
+    UnsubscribeFormDataById(formId);
 
     ApplicationInfo appInfo;
     if (FormBmsHelper::GetInstance().GetApplicationInfo(formRecord.bundleName, FormUtil::GetCurrentAccountId(),
@@ -83,20 +74,7 @@ ErrCode FormDataProxyMgr::SubscribeFormData(int64_t formId, const std::vector<Fo
 
 ErrCode FormDataProxyMgr::UnsubscribeFormData(int64_t formId)
 {
-    HILOG_INFO("unsubscribe form data. formId:%{public}" PRId64, formId);
-    std::shared_ptr<FormDataProxyRecord> record = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(formDataProxyRecordMutex_);
-        auto search = formDataProxyRecordMap_.find(formId);
-        if (search != formDataProxyRecordMap_.end()) {
-            record = search->second;
-            formDataProxyRecordMap_.erase(formId);
-        }
-    }
-    if (record != nullptr) {
-        record->UnsubscribeFormData();
-    }
-
+    UnsubscribeFormDataById(formId);
     return ERR_OK;
 }
 
@@ -175,5 +153,18 @@ void FormDataProxyMgr::GetFormSubscribeInfo(
         }
     }
 }
+
+void FormDataProxyMgr::UnsubscribeFormDataById(int64_t formId)
+{
+    HILOG_DEBUG("unsubscribe form data. formId:%{public}s", std::to_string(formId).c_str());
+    std::lock_guard<std::mutex> lock(formDataProxyRecordMutex_);
+    auto search = formDataProxyRecordMap_.find(formId);
+    if (search != formDataProxyRecordMap_.end()) {
+        if (search->second != nullptr) {
+            search->second->UnsubscribeFormData();
+        }
+        formDataProxyRecordMap_.erase(formId);
+    }
+}
 } // namespace AppExecFwk
 } // namespace OHOS
diff --git a/services/src/form_mgr/form_mgr_adapter.cpp b/services/src/form_mgr/form_mgr_adapter.cpp
index fc91f30a338f77863e78592094a11810a8eb79d8..18110b7720ee85382620460085fb931b848f51f4 100644
--- a/services/src/form_mgr/form_mgr_adapter.cpp
+++ b/services/src/form_mgr/form_mgr_adapter.cpp
@@ -386,39 +386,30 @@ void FormMgrAdapter::CancelAddFormRequestTimeOutTask(const int64_t formId, const
     std::lock_guard<std::mutex> lock(formResultMutex_);
     auto iter = formIdMap_.find(formId);
     if (iter != formIdMap_.end()) {
-        if (result != ERR_OK) {
-            iter->second = AddFormResultErrorCode::FAILED;
-        } else {
-            iter->second = AddFormResultErrorCode::SUCCESS;
-        }
+        const auto state = (result != ERR_OK ? AddFormResultErrorCode::FAILED : AddFormResultErrorCode::SUCCESS);
+        iter->second = state;
         condition_.notify_all();
     }
 }
 
-ErrCode FormMgrAdapter::CheckAddFormTaskTimeoutOrFailed(const int64_t formId, AddFormResultErrorCode &formStates)
+AddFormResultErrorCode FormMgrAdapter::GetFormResultErrCode(const int64_t formId)
 {
     std::lock_guard<std::mutex> lock(formResultMutex_);
-    auto result = std::find_if(formIdMap_.begin(), formIdMap_.end(), [this, formId, &formStates] (const auto elem) {
-        if (elem.first == formId) {
-            if (elem.second == AddFormResultErrorCode::FAILED) {
-                formIdMap_.erase(formId);
-                return true;
-            } else if (elem.second == AddFormResultErrorCode::TIMEOUT) {
-                formIdMap_.erase(formId);
-                return true;
-            } else if (elem.second == AddFormResultErrorCode::SUCCESS) {
-                formStates = AddFormResultErrorCode::SUCCESS;
-                return false;
-            } else {
-                formStates = AddFormResultErrorCode::UNKNOWN;
-                return false;
-            }
-        }
-        return false;
-    });
-    if (result != formIdMap_.end()) {
+    const auto iter = formIdMap_.find(formId);
+    if (iter != formIdMap_.end()) {
+        return iter->second;
+    }
+    return AddFormResultErrorCode::SUCCESS;
+}
+
+ErrCode FormMgrAdapter::CheckAddFormTaskTimeoutOrFailed(const int64_t formId, AddFormResultErrorCode &formStates)
+{
+    const auto state = GetFormResultErrCode(formId);
+    if (state == AddFormResultErrorCode::FAILED || state == AddFormResultErrorCode::TIMEOUT) {
+        RemoveFormIdMapElement(formId);
         return ERR_APPEXECFWK_FORM_COMMON_CODE;
     }
+    formStates = state;
     return ERR_OK;
 }
 
diff --git a/services/src/form_render/form_render_mgr_inner.cpp b/services/src/form_render/form_render_mgr_inner.cpp
index e40b5a638236734df98060afb3c7bcc43a2a9dab..f2ef8559d8963fbc42305fe4f99e4df92fe9661e 100644
--- a/services/src/form_render/form_render_mgr_inner.cpp
+++ b/services/src/form_render/form_render_mgr_inner.cpp
@@ -71,42 +71,14 @@ ErrCode FormRenderMgrInner::RenderForm(
     }
     FillBundleInfo(want, formRecord.bundleName);
 
-    bool connectionExisted = false;
     sptr<FormRenderConnection> connection = nullptr;
-    {
-        std::lock_guard<std::mutex> lock(resourceMutex_);
-        HILOG_DEBUG("renderFormConnections_ size:%{public}zu", renderFormConnections_.size());
-        auto conIterator = renderFormConnections_.find(formRecord.formId);
-        if (conIterator != renderFormConnections_.end()) {
-            connectionExisted = true;
-            connection = conIterator->second;
-        }
-    }
+    bool connectionExisted = GetRenderFormConnection(connection, formRecord.formId);
     if (connectionExisted) {
         if (connection == nullptr) {
             HILOG_ERROR("null connection");
             return ERR_APPEXECFWK_FORM_INVALID_PARAM;
         }
-        std::shared_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
-        if (renderRemoteObj_ == nullptr) {
-            connection->UpdateFormRecord(formRecord);
-            connection->UpdateWantParams(want.GetParams());
-            ErrCode ret = ConnectRenderService(connection, formRecord.privacyLevel);
-            HILOG_INFO("ret:%{public}d", ret);
-            if (ret) {
-                FormRenderMgr::GetInstance().HandleConnectFailed(formRecord.formId, ret);
-            }
-            return ret;
-        }
-        auto remoteObject = renderRemoteObj_->AsObject();
-        if (remoteObject == nullptr) {
-            HILOG_ERROR("null remoteObject");
-            return ERR_APPEXECFWK_FORM_INVALID_PARAM;
-        }
-        guard.unlock();
-        want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
-        FormTaskMgr::GetInstance().PostRenderForm(formRecord, want, remoteObject);
-        return ERR_OK;
+        return RenderConnectedForm(formRecord, want, connection);
     }
 
     auto formRenderConnection = new (std::nothrow) FormRenderConnection(formRecord, want.GetParams());
@@ -140,17 +112,11 @@ void FormRenderMgrInner::CheckIfFormRecycled(FormRecord &formRecord, Want& want)
 
 ErrCode FormRenderMgrInner::GetConnectionAndRenderForm(FormRecord &formRecord, Want &want)
 {
-    std::lock_guard<std::mutex> lock(resourceMutex_);
-    auto conIterator = renderFormConnections_.find(formRecord.formId);
-    if (conIterator == renderFormConnections_.end()) {
+    int32_t connectId = 0;
+    if (!GetRenderFormConnectId(formRecord.formId, connectId)) {
         HILOG_ERROR("Not find renderFormConnection");
         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
     }
-    auto connection = conIterator->second;
-    if (connection == nullptr) {
-        HILOG_ERROR("null connection");
-        return ERR_APPEXECFWK_FORM_INVALID_PARAM;
-    }
     sptr<IRemoteObject> remoteObject;
     auto ret = GetRenderObject(remoteObject);
     if (ret != ERR_OK) {
@@ -158,7 +124,7 @@ ErrCode FormRenderMgrInner::GetConnectionAndRenderForm(FormRecord &formRecord, W
         return ret;
     }
     CheckIfFormRecycled(formRecord, want);
-    want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
+    want.SetParam(Constants::FORM_CONNECT_ID, connectId);
     FormTaskMgr::GetInstance().PostRenderForm(formRecord, std::move(want), remoteObject);
     return ERR_OK;
 }
@@ -308,27 +274,7 @@ ErrCode FormRenderMgrInner::StopRenderingForm(int64_t formId, const FormRecord &
         want.SetParam(Constants::PARAM_FORM_HOST_TOKEN, hostToken);
     }
 
-    {
-        std::lock_guard<std::mutex> lock(resourceMutex_);
-        auto conIterator = renderFormConnections_.find(formRecord.formId);
-        if (conIterator != renderFormConnections_.end()) {
-            auto connection = conIterator->second;
-            if (connection == nullptr) {
-                HILOG_ERROR("null connection");
-                return ERR_APPEXECFWK_FORM_INVALID_PARAM;
-            }
-            sptr<IRemoteObject> remoteObject;
-            auto ret = GetRenderObject(remoteObject);
-            if (ret != ERR_OK) {
-                HILOG_ERROR("null remoteObjectGotten");
-                return ret;
-            }
-            want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
-            FormTaskMgr::GetInstance().PostStopRenderingForm(formRecord, std::move(want), remoteObject);
-            return ERR_OK;
-        }
-    }
-    return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+    return PostStopRenderingFormTask(formRecord, want);
 }
 
 ErrCode FormRenderMgrInner::StopRenderingFormCallback(int64_t formId, const Want &want)
@@ -378,27 +324,19 @@ ErrCode FormRenderMgrInner::ReleaseRenderer(int64_t formId, const FormRecord &fo
         return ERR_APPEXECFWK_FORM_INVALID_PARAM;
     }
 
-    std::string uid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
-    {
-        std::lock_guard<std::mutex> lock(resourceMutex_);
-        auto conIterator = renderFormConnections_.find(formRecord.formId);
-        if (conIterator != renderFormConnections_.end()) {
-            auto connection = conIterator->second;
-            if (connection == nullptr) {
-                HILOG_ERROR("null connection");
-                return ERR_APPEXECFWK_FORM_INVALID_PARAM;
-            }
-            sptr<IRemoteObject> remoteObject;
-            auto ret = GetRenderObject(remoteObject);
-            if (ret != ERR_OK) {
-                HILOG_ERROR("null remoteObjectGotten");
-                return ret;
-            }
-            FormTaskMgr::GetInstance().PostReleaseRenderer(formId, compId, uid, remoteObject, formRecord.isDynamic);
-            return ERR_OK;
-        }
+    if (CheckRenderConnectionExistById(formRecord.formId) != ERR_OK) {
+        HILOG_ERROR("null connection");
+        return ERR_APPEXECFWK_FORM_INVALID_PARAM;
     }
-    return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+    sptr<IRemoteObject> remoteObject;
+    auto ret = GetRenderObject(remoteObject);
+    if (ret != ERR_OK) {
+        HILOG_ERROR("null remoteObjectGotten");
+        return ret;
+    }
+    std::string uid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
+    FormTaskMgr::GetInstance().PostReleaseRenderer(formId, compId, uid, remoteObject, formRecord.isDynamic);
+    return ERR_OK;
 }
 
 ErrCode FormRenderMgrInner::AddConnection(int64_t formId, sptr<FormRenderConnection> connection)
@@ -702,21 +640,8 @@ ErrCode FormRenderMgrInner::RecycleForms(
         return ret;
     }
 
-    std::lock_guard<std::mutex> lock(resourceMutex_);
     std::vector<int64_t> connectedForms;
-    for (const int64_t &formId : formIds) {
-        auto conIterator = renderFormConnections_.find(formId);
-        if (conIterator != renderFormConnections_.end()) {
-            auto connection = conIterator->second;
-            if (connection == nullptr) {
-                HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
-                continue;
-            }
-            connectedForms.emplace_back(formId);
-        } else {
-            HILOG_ERROR("can't find connection of %{public}" PRId64, formId);
-        }
-    }
+    GetConnectedForms(formIds, connectedForms);
     FormTaskMgr::GetInstance().PostRecycleForms(connectedForms, want, remoteObjectOfHost, remoteObject);
     return ERR_OK;
 }
@@ -750,16 +675,9 @@ ErrCode FormRenderMgrInner::RecoverForms(const std::vector<int64_t> &formIds, co
         std::string uid = std::to_string(formRecord.providerUserId) + formRecord.bundleName;
         want.SetParam(Constants::FORM_SUPPLY_UID, uid);
 
-        std::lock_guard<std::mutex> lock(resourceMutex_);
-        auto conIterator = renderFormConnections_.find(formId);
-        if (conIterator != renderFormConnections_.end()) {
-            auto connection = conIterator->second;
-            if (connection == nullptr) {
-                HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
-                continue;
-            }
-            want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
-
+        int32_t connectId = 0;
+        if (GetRenderFormConnectId(formId, connectId)) {
+            want.SetParam(Constants::FORM_CONNECT_ID, connectId);
             std::string statusData;
             if (FormInfoRdbStorageMgr::GetInstance().LoadStatusData(std::to_string(formId), statusData) != ERR_OK) {
                 HILOG_ERROR("read status data of %{public}" PRId64 " failed.", formId);
@@ -809,6 +727,121 @@ ErrCode FormRenderMgrInner::GetRenderObject(sptr<IRemoteObject> &renderObj)
     return ERR_OK;
 }
 
+bool FormRenderMgrInner::GetRenderFormConnectId(const int64_t formId, int32_t& connectId)
+{
+    std::lock_guard<std::mutex> lock(resourceMutex_);
+    auto conIterator = renderFormConnections_.find(formId);
+    if (conIterator != renderFormConnections_.end()) {
+        auto connection = conIterator->second;
+        if (connection == nullptr) {
+            HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
+            return false;
+        }
+        connectId = connection->GetConnectId();
+        return true;
+    }
+    HILOG_ERROR("Not find renderFormConnection. formId: %{public}" PRId64, formId);
+    return false;
+}
+
+bool FormRenderMgrInner::GetRenderFormConnection(sptr<FormRenderConnection>& connection, const int64_t formId)
+{
+    std::lock_guard<std::mutex> lock(resourceMutex_);
+    HILOG_DEBUG("renderFormConnections_ size:%{public}zu", renderFormConnections_.size());
+    auto conIterator = renderFormConnections_.find(formId);
+    if (conIterator != renderFormConnections_.end()) {
+        connection = conIterator->second;
+        return true;
+    }
+    return false;
+}
+
+void FormRenderMgrInner::GetConnectedForms(const std::vector<int64_t> &formIds, std::vector<int64_t>& connectedForms)
+{
+    std::lock_guard<std::mutex> lock(resourceMutex_);
+    for (const int64_t &formId : formIds) {
+        auto conIterator = renderFormConnections_.find(formId);
+        if (conIterator != renderFormConnections_.end()) {
+            auto connection = conIterator->second;
+            if (connection == nullptr) {
+                HILOG_ERROR("connection of %{public}" PRId64 " is null.", formId);
+                continue;
+            }
+            connectedForms.emplace_back(formId);
+        } else {
+            HILOG_ERROR("can't find connection of %{public}" PRId64, formId);
+        }
+    }
+}
+
+ErrCode FormRenderMgrInner::RenderConnectedForm(const FormRecord &formRecord, Want &want,
+                                                const sptr<FormRenderConnection>& connection)
+{
+    if (connection == nullptr) {
+        HILOG_ERROR("null connection");
+        return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+    }
+
+    std::shared_lock<std::shared_mutex> guard(renderRemoteObjMutex_);
+    if (renderRemoteObj_ == nullptr) {
+        connection->UpdateFormRecord(formRecord);
+        connection->UpdateWantParams(want.GetParams());
+        ErrCode ret = ConnectRenderService(connection, formRecord.privacyLevel);
+        HILOG_INFO("ret:%{public}d", ret);
+        if (ret) {
+            FormRenderMgr::GetInstance().HandleConnectFailed(formRecord.formId, ret);
+        }
+        return ret;
+    }
+    auto remoteObject = renderRemoteObj_->AsObject();
+    if (remoteObject == nullptr) {
+        HILOG_ERROR("null remoteObject");
+        return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+    }
+    guard.unlock();
+    want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
+    FormTaskMgr::GetInstance().PostRenderForm(formRecord, want, remoteObject);
+    return ERR_OK;
+}
+
+ErrCode FormRenderMgrInner::PostStopRenderingFormTask(const FormRecord &formRecord, Want &want)
+{
+    std::lock_guard<std::mutex> lock(resourceMutex_);
+    auto conIterator = renderFormConnections_.find(formRecord.formId);
+    if (conIterator != renderFormConnections_.end()) {
+        auto connection = conIterator->second;
+        if (connection == nullptr) {
+            HILOG_ERROR("null connection");
+            return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+        }
+        sptr<IRemoteObject> remoteObject;
+        auto ret = GetRenderObject(remoteObject);
+        if (ret != ERR_OK) {
+            HILOG_ERROR("null remoteObjectGotten");
+            return ret;
+        }
+        want.SetParam(Constants::FORM_CONNECT_ID, connection->GetConnectId());
+        FormTaskMgr::GetInstance().PostStopRenderingForm(formRecord, std::move(want), remoteObject);
+        return ERR_OK;
+    }
+    return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+}
+
+ErrCode FormRenderMgrInner::CheckRenderConnectionExistById(int64_t formId)
+{
+    std::lock_guard<std::mutex> lock(resourceMutex_);
+    auto conIterator = renderFormConnections_.find(formId);
+    if (conIterator != renderFormConnections_.end()) {
+        auto connection = conIterator->second;
+        if (connection == nullptr) {
+            HILOG_ERROR("null connection");
+            return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+        }
+        return ERR_OK;
+    }
+    return ERR_APPEXECFWK_FORM_INVALID_PARAM;
+}
+
 void FormRenderRecipient::OnRemoteDied(const wptr<IRemoteObject> &remote)
 {
     HILOG_INFO("Recv FormRenderService death notice");