diff --git a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp
index 8d24febd6e617bfc38fb4c69c72580df52aa767b..da739506b823cf968a10235bc0d40b8c252d12c2 100644
--- a/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp
+++ b/interfaces/kits/napi/file_access_module/napi_fileaccess_helper.cpp
@@ -25,7 +25,6 @@
 #include "ifile_access_notify.h"
 #include "napi_base_context.h"
 #include "napi_common_fileaccess.h"
-#include "napi_error.h"
 #include "napi_notify_callback.h"
 #include "n_val.h"
 #include "securec.h"
@@ -44,15 +43,18 @@ namespace {
 }
 
 std::list<std::shared_ptr<FileAccessHelper>> g_fileAccessHelperList;
+std::mutex fileMutex;
 
 static napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info info)
 {
+    HILOG_ERROR("**Releae last7**");
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
+    HILOG_ERROR("**Releae last6**");
     napi_value thisVar = funcArg.GetThisVar();
     std::shared_ptr<FileAccessHelper> fileAccessHelper = nullptr;
     bool isStageMode = false;
@@ -62,44 +64,70 @@ static napi_value FileAccessHelperConstructor(napi_env env, napi_callback_info i
         return nullptr;
     }
 
+    HILOG_ERROR("**Releae last5**");
     auto context = OHOS::AbilityRuntime::GetStageModeContext(env, funcArg.GetArg(PARAM0));
     if (context == nullptr) {
         HILOG_ERROR("FileAccessHelperConstructor: failed to get native context");
         return nullptr;
     }
 
+    HILOG_ERROR("**Releae last4**");
     if (funcArg.GetArgc() == NARG_CNT::ONE) {
+        HILOG_ERROR("**Releae 11**");
         fileAccessHelper = FileAccessHelper::Creator(context);
     } else if (funcArg.GetArgc() == NARG_CNT::TWO) {
         std::vector<AAFwk::Want> wants;
+        HILOG_ERROR("**Releae 22**");
         bool suss = UnwrapArrayWantFromJS(env, funcArg.GetArg(PARAM1), wants);
         if (!suss) {
+            HILOG_ERROR("**Releae 33**");
             HILOG_ERROR("UnwrapArrayWantFromJS failed to get native wants");
             return nullptr;
         }
+        HILOG_ERROR("**Releae 44**");
         fileAccessHelper = FileAccessHelper::Creator(context, wants);
     }
 
+    HILOG_ERROR("**Releae last3**");
     if (fileAccessHelper == nullptr) {
+        HILOG_ERROR("**Releae 55**");
         HILOG_ERROR("FileAccessHelperConstructor: fileAccessHelper is nullptr");
         return nullptr;
     }
-    g_fileAccessHelperList.emplace_back(fileAccessHelper);
+    {
+	    std::lock_guard<std::mutex> lock(fileMutex);
+        g_fileAccessHelperList.emplace_back(fileAccessHelper);
+    }
 
+    HILOG_ERROR("**Releae last1**");
     auto finalize = [](napi_env env, void *data, void *hint) {
+
+     HILOG_ERROR("**Releae 66**");
         FileAccessHelper *objectInfo = static_cast<FileAccessHelper *>(data);
+         HILOG_ERROR("**Releae 77*1*");
+	{
+	    std::lock_guard<std::mutex> lock(fileMutex);
         g_fileAccessHelperList.remove_if([objectInfo](const std::shared_ptr<FileAccessHelper> &fileAccessHelper) {
-                return objectInfo == fileAccessHelper.get();
-            });
-        if (objectInfo != nullptr) {
-            objectInfo->Release();
-            delete objectInfo;
-        }
+			HILOG_ERROR("**Releae last2**");
+				return objectInfo == fileAccessHelper.get();
+			 });
+	}
+             HILOG_ERROR("**Releae last22**");
+         if (objectInfo != nullptr) {
+             HILOG_ERROR("**Releae objectInfo != nullptr**");
+             objectInfo->Release();
+             HILOG_ERROR("**Releae 88**");
+             delete objectInfo;
+         }
     };
+
+    HILOG_ERROR("**Releae 99**");
     if (napi_wrap(env, thisVar, fileAccessHelper.get(), finalize, nullptr, nullptr) != napi_ok) {
+        HILOG_ERROR("**Releae 10**");
         finalize(env, fileAccessHelper.get(), nullptr);
         return nullptr;
     }
+    HILOG_ERROR("**Releae 100**");
     return thisVar;
 }
 
@@ -107,7 +135,7 @@ napi_value AcquireFileAccessHelperWrap(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -168,7 +196,7 @@ napi_value NAPI_GetRegisterFileAccessExtAbilityInfo(napi_env env, napi_callback_
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ZERO, NARG_CNT::ONE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -191,7 +219,7 @@ napi_value NAPI_GetRegisterFileAccessExtAbilityInfo(napi_env env, napi_callback_
     }
     NVal cb(env, funcArg[NARG_POS::FIRST]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "argument type unmatched");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -222,7 +250,10 @@ napi_value FileAccessHelperInit(napi_env env, napi_value exports)
             sizeof(properties) / sizeof(*properties),
             properties,
             &cons));
-    g_fileAccessHelperList.clear();
+    {
+	    std::lock_guard<std::mutex> lock(fileMutex);
+        g_fileAccessHelperList.clear();
+    }
     NAPI_CALL(env, napi_create_reference(env, cons, INITIAL_REFCOUNT, &g_constructorRef));
     NAPI_CALL(env, napi_set_named_property(env, exports, FILEACCESS_CLASS_NAME.c_str(), cons));
 
@@ -238,14 +269,14 @@ napi_value FileAccessHelperInit(napi_env env, napi_value exports)
 static FileAccessHelper *GetFileAccessHelper(napi_env env, napi_value thisVar)
 {
     if (thisVar == nullptr) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "thisVar is nullper");
         return nullptr;
     }
 
     FileAccessHelper *fileAccessHelper = nullptr;
     napi_unwrap(env, thisVar, (void **)&fileAccessHelper);
     if (fileAccessHelper == nullptr) {
-        NapiError(ERR_GET_FILEACCESS_HELPER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "fileAccessHelper is nullper");
         return nullptr;
     }
     return fileAccessHelper;
@@ -260,13 +291,13 @@ static std::tuple<bool, std::unique_ptr<char[]>, std::unique_ptr<char[]>> GetRea
     std::unique_ptr<char[]> name = nullptr;
     std::tie(succ, uri, std::ignore) = NVal(env, sourceFile).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "first parameter is Invalid");
         return { false, std::move(uri), std::move(name) };
     }
 
     std::tie(succ, name, std::ignore) = NVal(env, targetParent).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "second parameter is Invalid");
         return { false, std::move(uri), std::move(name) };
     }
 
@@ -277,7 +308,7 @@ napi_value NAPI_OpenFile(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -285,14 +316,14 @@ napi_value NAPI_OpenFile(napi_env env, napi_callback_info info)
     std::unique_ptr<char[]> uri;
     std::tie(succ, uri, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Invalid uri");
         return nullptr;
     }
 
     int flags;
     std::tie(succ, flags) = NVal(env, funcArg[NARG_POS::SECOND]).ToInt32();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Invalid flags");
         return nullptr;
     }
 
@@ -323,7 +354,7 @@ napi_value NAPI_OpenFile(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::THIRD]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -333,7 +364,7 @@ napi_value NAPI_CreateFile(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -375,7 +406,7 @@ napi_value NAPI_CreateFile(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::THIRD]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -385,7 +416,7 @@ napi_value NAPI_Mkdir(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -427,7 +458,7 @@ napi_value NAPI_Mkdir(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::THIRD]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -437,7 +468,7 @@ napi_value NAPI_Delete(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -445,7 +476,7 @@ napi_value NAPI_Delete(napi_env env, napi_callback_info info)
     std::unique_ptr<char[]> uri;
     std::tie(succ, uri, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Invalid uri");
         return nullptr;
     }
 
@@ -476,7 +507,7 @@ napi_value NAPI_Delete(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::SECOND]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -486,7 +517,7 @@ napi_value NAPI_Move(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -529,7 +560,7 @@ napi_value NAPI_Move(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::THIRD]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -539,7 +570,7 @@ napi_value NAPI_Rename(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::TWO, NARG_CNT::THREE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -581,7 +612,7 @@ napi_value NAPI_Rename(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::THIRD]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -591,7 +622,7 @@ napi_value NAPI_ListFile(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -599,7 +630,7 @@ napi_value NAPI_ListFile(napi_env env, napi_callback_info info)
     std::unique_ptr<char[]> uri;
     std::tie(succ, uri, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Invalid uri");
         return nullptr;
     }
 
@@ -631,7 +662,7 @@ napi_value NAPI_ListFile(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::SECOND]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -641,7 +672,7 @@ napi_value NAPI_GetRoots(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ZERO, NARG_CNT::ONE)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -672,7 +703,7 @@ napi_value NAPI_GetRoots(napi_env env, napi_callback_info info)
 
     NVal cb(env, funcArg[NARG_POS::FIRST]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -682,7 +713,7 @@ napi_value NAPI_IsFileExist(napi_env env, napi_callback_info info)
 {
     NFuncArg funcArg(env, info);
     if (!funcArg.InitArgs(NARG_CNT::ONE, NARG_CNT::TWO)) {
-        NapiError(ERR_PARAM_NUMBER).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Number of arguments unmatched");
         return nullptr;
     }
 
@@ -690,7 +721,7 @@ napi_value NAPI_IsFileExist(napi_env env, napi_callback_info info)
     std::unique_ptr<char[]> uri;
     std::tie(succ, uri, std::ignore) = NVal(env, funcArg[NARG_POS::FIRST]).ToUTF8String();
     if (!succ) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "Invalid uri");
         return nullptr;
     }
 
@@ -722,7 +753,7 @@ napi_value NAPI_IsFileExist(napi_env env, napi_callback_info info)
     }
     NVal cb(env, funcArg[NARG_POS::SECOND]);
     if (!cb.TypeIs(napi_function)) {
-        NapiError(ERR_INVALID_PARAM).ThrowErr(env);
+        NError(EINVAL).ThrowErr(env, "not function type");
         return nullptr;
     }
     return NAsyncWorkCallback(env, thisVar, cb).Schedule(procedureName, cbExec, cbComplete).val_;
@@ -807,4 +838,4 @@ napi_value NAPI_Off(napi_env env, napi_callback_info info)
     return NVal::CreateUndefined(env).val_;
 }
 } // namespace FileAccessFwk
-} // namespace OHOS
\ No newline at end of file
+} // namespace OHOS