diff --git a/interfaces/kits/js/src/mod_fs/ani/ets/@ohos.file.fs.ets b/interfaces/kits/js/src/mod_fs/ani/ets/@ohos.file.fs.ets
index e8fa2c76b075561079fd9bf88589c471047d6430..630fd55e7682c4f993c196d0f4d6a43902f907b5 100644
--- a/interfaces/kits/js/src/mod_fs/ani/ets/@ohos.file.fs.ets
+++ b/interfaces/kits/js/src/mod_fs/ani/ets/@ohos.file.fs.ets
@@ -31,27 +31,15 @@ namespace fileIo {
 
 function access(path: string, mode?: AccessModeType): Promise<boolean> {
   return new Promise<boolean>((resolve: (result: boolean) => void, reject: (e: BusinessError<void>) => void) => {
-    if (mode === undefined) {
-      let promise = taskpool.execute((path: string): boolean => {
-        return FileIoImpl.doAccessSync(path);
-      }, path);
-      promise.then((ret: NullishType) => {
-        let result = ret as boolean;
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((path: string, mode: AccessModeType): boolean => {
-        return FileIoImpl.doAccessSync(path, mode);
-      }, path, mode);
-      promise.then((ret: NullishType) => {
-        let result = ret as boolean;
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((path: string, mode?: AccessModeType): boolean => {
+      return FileIoImpl.doAccessSync(path, mode);
+    }, path, mode);
+    promise.then((ret: NullishType): void => {
+      let result = ret as boolean;
+      resolve(result);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
@@ -71,7 +59,9 @@ function access(path: string, callback: AsyncCallback<boolean>): void {
 
 function access(path: string, mode: AccessModeType, flag: AccessFlagType): Promise<boolean> {
   return new Promise<boolean>((resolve: (result: boolean) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.doAccessSync, path, mode, flag);
+    let promise = taskpool.execute((path: string, mode: AccessModeType, flag: AccessFlagType): boolean => {
+      return FileIoImpl.doAccessSync(path, mode, flag);
+    }, path, mode, flag);
     promise.then((ret: NullishType): void => {
       let result = ret as boolean;
       resolve(result);
@@ -144,7 +134,9 @@ function getxattrSync(path: string, key: string): string {
 
 function getxattr(path: string, key: string): Promise<string> {
   return new Promise<string>((resolve: (result: string) => void, reject: (e: BusinessError<void>) => void): void => {
-    let promise = taskpool.execute(FileIoImpl.getxattrSync, path, key);
+    let promise = taskpool.execute((path: string, key: string): string => {
+      return FileIoImpl.getxattrSync(path, key);
+    }, path, key);
     promise.then((ret: NullishType): void => {
       let result = ret as string;
       resolve(result);
@@ -163,25 +155,15 @@ function copyDirSync(src: string, dest: string, mode?: number): void {
 }
 
 function copyDir(src: string, dest: string, mode?: number): Promise<void> {
-  return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<Array<ConflictFiles>>) => void): void => {
-    if (mode === undefined) {
-      let promise = taskpool.execute((src: string, dest: string): undefined =>
-        FileIoImpl.copyDirSync(src, dest), src, dest);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((src: string, dest: string, mode: number): undefined =>
-        FileIoImpl.copyDirSync(src, dest, mode), src, dest, mode);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
-        reject(e);
-      });
-    }
-
+  return new Promise<void>((resolve: (result: undefined) => void,
+    reject: (e: BusinessError<Array<ConflictFiles>>) => void): void => {
+    let promise = taskpool.execute((src: string, dest: string, mode?: number): undefined =>
+      FileIoImpl.copyDirSync(src, dest, mode), src, dest, mode);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
+      reject(e);
+    });
   });
 }
 
@@ -329,25 +311,14 @@ function moveDirSync(src: string, dest: string, mode?: number): void {
 function moveDir(src: string, dest: string, mode?: number): Promise<void> {
   return new Promise<void>((resolve: (result: undefined) => void,
     reject: (e: BusinessError<Array<ConflictFiles>>) => void): void => {
-    if (mode === undefined) {
-      let promise = taskpool.execute((src: string, dest: string): undefined => {
-        return FileIoImpl.movedirSync(src, dest);
-      }, src, dest);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((src: string, dest: string, mode: number): undefined => {
-        return FileIoImpl.movedirSync(src, dest, mode);
-      }, src, dest, mode);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((src: string, dest: string, mode?: number): undefined => {
+      return FileIoImpl.movedirSync(src, dest, mode);
+    }, src, dest, mode);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError<Array<ConflictFiles>>): void => {
+      reject(e);
+    });
   })
 }
 
@@ -406,7 +377,9 @@ function mkdtempSync(prefix: string): string {
 
 function mkdtemp(prefix: string): Promise<string> {
   return new Promise<string>((resolve: (result: string) => void, reject: (e: BusinessError<void>) => void): void => {
-    let promise = taskpool.execute(FileIoImpl.mkdtempSync, prefix);
+    let promise = taskpool.execute((prefix: string): string => {
+      return FileIoImpl.mkdtempSync(prefix);
+    }, prefix);
     promise.then((ret: NullishType): void => {
       let result = ret as string;
       resolve(result);
@@ -417,7 +390,9 @@ function mkdtemp(prefix: string): Promise<string> {
 }
 
 function mkdtemp(prefix: string, callback: AsyncCallback<string>): void {
-  let promise = taskpool.execute(FileIoImpl.mkdtempSync, prefix);
+  let promise = taskpool.execute((prefix: string): string => {
+    return FileIoImpl.mkdtempSync(prefix);
+  }, prefix);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -434,25 +409,14 @@ function moveFileSync(src: string, dest: string, mode?: number): void {
 
 function moveFile(src: string, dest: string, mode?: number): Promise<void> {
   return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
-    if (mode === undefined) {
-      let promise = taskpool.execute((src: string, dest: string): undefined => {
-        return FileIoImpl.moveFileSync(src, dest);
-      }, src, dest);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((src: string, dest: string, mode: number): undefined => {
-        return FileIoImpl.moveFileSync(src, dest, mode);
-      }, src, dest, mode);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((src: string, dest: string, mode?: number): undefined => {
+      return FileIoImpl.moveFileSync(src, dest, mode);
+    }, src, dest, mode);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
@@ -488,7 +452,9 @@ function openSync(path: string, mode?: number): File {
 
 function open(path: String, mode?: number): Promise<File> {
   return new Promise<File>((resolve: (result: File) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.openSync, path, mode);
+    let promise = taskpool.execute((path: String, mode?: number): File => {
+      return FileIoImpl.openSync(path, mode);
+    },path, mode);
     promise.then((ret: NullishType): void => {
       let file = ret as File;
       resolve(file);
@@ -499,7 +465,9 @@ function open(path: String, mode?: number): Promise<File> {
 }
 
 function open(path: String, mode: number, callback: AsyncCallback<File, void>): void {
-  let promise = taskpool.execute(FileIoImpl.openSync, path, mode);
+  let promise = taskpool.execute((path: String, mode: number): File => {
+    return FileIoImpl.openSync(path, mode);
+  }, path, mode);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -512,7 +480,9 @@ function open(path: String, mode: number, callback: AsyncCallback<File, void>):
 }
 
 function open(path: String, callback: AsyncCallback<File, void>): void {
-  let promise = taskpool.execute(FileIoImpl.openSync, path);
+  let promise = taskpool.execute((path: String): File => {
+    return FileIoImpl.openSync(path);
+  }, path);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -530,29 +500,23 @@ function writeSync(fd: number, buffer: string | ArrayBuffer, options?: WriteOpti
 
 function write(fd: number, buffer: string | ArrayBuffer, options?: WriteOptions): Promise<number> {
   return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-    if (options === undefined) {
-      let promise = taskpool.execute(FileIoImpl.writeSync, fd, buffer, options);
-      promise.then((ret: NullishType): void => {
-        let result = ret as number
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute(FileIoImpl.writeSync, fd, buffer, options);
-      promise.then((ret: NullishType): void => {
-        let result = ret as number
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((fd: number, buffer: string | ArrayBuffer, options?: WriteOptions): number => {
+      return FileIoImpl.writeSync(fd, buffer, options);
+    }, fd, buffer, options);
+    promise.then((ret: NullishType): void => {
+      let result = ret as number
+      resolve(result);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
 function write(fd: number, buffer: string | ArrayBuffer, options: WriteOptions,
   callback: AsyncCallback<number, void>): void {
-  let promise = taskpool.execute(FileIoImpl.writeSync, fd, buffer, options);
+  let promise = taskpool.execute((fd: number, buffer: string | ArrayBuffer, options: WriteOptions): number => {
+    return FileIoImpl.writeSync(fd, buffer, options);
+  }, fd, buffer, options);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -564,7 +528,9 @@ function write(fd: number, buffer: string | ArrayBuffer, options: WriteOptions,
 }
 
 function write(fd: number, buffer: string | ArrayBuffer, callback: AsyncCallback<number, void>): void {
-  let promise = taskpool.execute(FileIoImpl.writeSync, fd, buffer);
+  let promise = taskpool.execute((fd: number, buffer: string | ArrayBuffer): number => {
+    return FileIoImpl.writeSync(fd, buffer);
+  }, fd, buffer);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -581,32 +547,22 @@ function readSync(fd: number, buffer: ArrayBuffer, options?: ReadOptions): numbe
 
 function read(fd: number, buffer: ArrayBuffer, options?: ReadOptions): Promise<number> {
   return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-    if (options === undefined) {
-      let promise = taskpool.execute((fd: number, buffer: ArrayBuffer): number => {
-        return FileIoImpl.readSync(fd, buffer);
-      }, fd, buffer);
-      promise.then((ret: NullishType) => {
-        let result = ret as number;
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((fd: number, buffer: ArrayBuffer, options: ReadOptions): number => {
-        return FileIoImpl.readSync(fd, buffer, options)
-      }, fd, buffer, options);
-      promise.then((ret: NullishType) => {
-        let result = ret as number;
-        resolve(result);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((fd: number, buffer: ArrayBuffer, options?: ReadOptions): number => {
+      return FileIoImpl.readSync(fd, buffer, options)
+    }, fd, buffer, options);
+    promise.then((ret: NullishType) => {
+      let result = ret as number;
+      resolve(result);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
 function read(fd: number, buffer: ArrayBuffer, callback: AsyncCallback<number, void>): void {
-  let promise = taskpool.execute(FileIoImpl.readSync, fd, buffer);
+  let promise = taskpool.execute((fd: number, buffer: ArrayBuffer): number => {
+    return FileIoImpl.readSync(fd, buffer);
+  }, fd, buffer);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -618,7 +574,9 @@ function read(fd: number, buffer: ArrayBuffer, callback: AsyncCallback<number, v
 }
 
 function read(fd: number, buffer: ArrayBuffer, options: ReadOptions, callback: AsyncCallback<number, void>): void {
-  let promise = taskpool.execute(FileIoImpl.readSync, fd, buffer, options);
+  let promise = taskpool.execute((fd: number, buffer: ArrayBuffer, options: ReadOptions): number => {
+    return FileIoImpl.readSync(fd, buffer, options);
+  }, fd, buffer, options);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -634,29 +592,24 @@ function readLinesSync(filePath: string, options?: Options): ReaderIterator {
 }
 
 function readLines(filePath: string, options?: Options): Promise<ReaderIterator> {
-  return new Promise<ReaderIterator>((resolve: (result: ReaderIterator) => void, reject: (e: BusinessError<void>) => void) => {
-    if (options === undefined) {
-      let promise = taskpool.execute(FileIoImpl.readlinesSync, filePath);
-      promise.then((ret: NullishType): void => {
-        let it = ret as ReaderIterator;
-        resolve(it);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute(FileIoImpl.readlinesSync, filePath, options);
-      promise.then((ret: NullishType): void => {
-        let it = ret as ReaderIterator;
-        resolve(it);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+  return new Promise<ReaderIterator>((resolve: (result: ReaderIterator) => void,
+    reject: (e: BusinessError<void>) => void) => {
+    let promise = taskpool.execute((filePath: string, options?: Options): ReaderIterator => {
+      return FileIoImpl.readlinesSync(filePath, options);
+    }, filePath, options);
+    promise.then((ret: NullishType): void => {
+      let it = ret as ReaderIterator;
+      resolve(it);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
 function readLines(filePath: string, callback: AsyncCallback<ReaderIterator>): void {
-  let promise = taskpool.execute(FileIoImpl.readlinesSync, filePath);
+  let promise = taskpool.execute((filePath: string): ReaderIterator => {
+    return FileIoImpl.readlinesSync(filePath);
+  }, filePath);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -669,7 +622,9 @@ function readLines(filePath: string, callback: AsyncCallback<ReaderIterator>): v
 }
 
 function readLines(filePath: string, options: Options, callback: AsyncCallback<ReaderIterator>): void {
-  let promise = taskpool.execute(FileIoImpl.readlinesSync, filePath, options);
+  let promise = taskpool.execute((filePath: string, options: Options): ReaderIterator => {
+    return FileIoImpl.readlinesSync(filePath, options);
+  }, filePath, options);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -714,25 +669,14 @@ function truncateSync(file: string | number, len?: number): void {
 
 function truncate(file: string | number, len?: number): Promise<void> {
   return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
-    if (len === undefined) {
-      let promise = taskpool.execute((file: string | number): undefined => {
-        return FileIoImpl.truncateSync(file);
-      }, file);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((file: string | number, len: number): undefined => {
-        return FileIoImpl.truncateSync(file, len);
-      }, file, len);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((file: string | number, len?: number): undefined => {
+      return FileIoImpl.truncateSync(file, len);
+    }, file, len);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   })
 }
 
@@ -791,28 +735,22 @@ function unlink(path: string, callback: AsyncCallback<void>): void {
 
 function readText(filePath: string, options?: ReadTextOptions): Promise<string> {
   return new Promise<string>((resolve: (result: string) => void, reject: (e: BusinessError<void>) => void) => {
-    if (options === undefined) {
-      let promise = taskpool.execute(FileIoImpl.readTextSync, filePath);
-      promise.then((ret: NullishType): void => {
-        let r = ret as string;
-        resolve(r);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute(FileIoImpl.readTextSync, filePath, options);
-      promise.then((ret: NullishType): void => {
-        let r = ret as string;
-        resolve(r);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((filePath: string, options?: ReadTextOptions): string => {
+      return FileIoImpl.readTextSync(filePath, options);
+    }, filePath, options);
+    promise.then((ret: NullishType): void => {
+      let r = ret as string;
+      resolve(r);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });   
   });
 }
 
 function readText(filePath: string, callback: AsyncCallback<string>): void {
-  let promise = taskpool.execute(FileIoImpl.readTextSync, filePath);
+  let promise = taskpool.execute((filePath: string): string => {
+    return FileIoImpl.readTextSync(filePath);
+  }, filePath);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -824,7 +762,9 @@ function readText(filePath: string, callback: AsyncCallback<string>): void {
 }
 
 function readText(filePath: string, options: ReadTextOptions, callback: AsyncCallback<string>): void {
-  let promise = taskpool.execute(FileIoImpl.readTextSync, filePath, options);
+  let promise = taskpool.execute((filePath: string, options: ReadTextOptions): string => {
+    return FileIoImpl.readTextSync(filePath, options);
+  }, filePath, options);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -841,28 +781,22 @@ function readTextSync(filePath: string, options?: ReadTextOptions): string {
 
 function listFile(path: string, options?: ListFileOptions): Promise<string[]> {
   return new Promise<string[]>((resolve: (result: string[]) => void, reject: (e: BusinessError<void>) => void) => {
-    if (options === undefined) {
-      let promise = taskpool.execute(FileIoImpl.listFileSync, path);
-      promise.then((ret: NullishType): void => {
-        let r = ret as string[];
-        resolve(r);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute(FileIoImpl.listFileSync, path, options);
-      promise.then((ret: NullishType): void => {
-        let r = ret as string[];
-        resolve(r);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((path: string, options?: ListFileOptions):  string[] => {
+      return FileIoImpl.listFileSync(path, options);
+    }, path, options);
+    promise.then((ret: NullishType): void => {
+      let r = ret as string[];
+      resolve(r);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
 function listFile(path: string, callback: AsyncCallback<string[]>): void {
-  let promise = taskpool.execute(FileIoImpl.listFileSync, path);
+  let promise = taskpool.execute((path: string): string[] => {
+    return FileIoImpl.listFileSync(path);
+  }, path);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -874,7 +808,9 @@ function listFile(path: string, callback: AsyncCallback<string[]>): void {
 }
 
 function listFile(path: string, options: ListFileOptions, callback: AsyncCallback<string[]>): void {
-  let promise = taskpool.execute(FileIoImpl.listFileSync, path, options);
+  let promise = taskpool.execute((path: string, options: ListFileOptions): string[] => {
+    return FileIoImpl.listFileSync(path, options);
+  }, path, options);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -899,7 +835,9 @@ function statSync(file: string | number): Stat {
 
 function stat(file: string | number): Promise<Stat> {
   return new Promise<Stat>((resolve: (result: Stat) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.statSync, file);
+    let promise = taskpool.execute((file: string | number): Stat => {
+      return FileIoImpl.statSync(file);
+    }, file);
     promise.then((ret: NullishType): void => {
       let r = ret as Stat;
       resolve(r);
@@ -910,7 +848,9 @@ function stat(file: string | number): Promise<Stat> {
 }
 
 function stat(file: string | number, callback: AsyncCallback<Stat, void>): void {
-  let p = taskpool.execute(FileIoImpl.statSync, file);
+  let p = taskpool.execute((file: string | number): Stat => {
+    return FileIoImpl.statSync(file);
+  }, file);
   p.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -1007,27 +947,10 @@ function createRandomAccessFile(file: string | File, mode?: number,
   options?: RandomAccessFileOptions): Promise<RandomAccessFile> {
   return new Promise<RandomAccessFile>((resolve: (result: RandomAccessFile) => void,
     reject: (e: BusinessError<void>) => void) => {
-    if (mode === undefined) {
-      let promise = taskpool.execute(FileIoImpl.createRandomAccessFileSync, file);
-      promise.then((ret: NullishType): void => {
-        let raffile = ret as RandomAccessFileInner;
-        resolve(raffile);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-      return;
-    }
-    if (mode !== undefined && options === undefined) {
-      let promise = taskpool.execute(FileIoImpl.createRandomAccessFileSync, file, mode);
-      promise.then((ret: NullishType): void => {
-        let raffile = ret as RandomAccessFileInner;
-        resolve(raffile);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-      return;
-    }
-    let promise = taskpool.execute(FileIoImpl.createRandomAccessFileSync, file, mode, options);
+    let promise = taskpool.execute((file: string | File, mode?: number,
+      options?: RandomAccessFileOptions): RandomAccessFile => {
+      return FileIoImpl.createRandomAccessFileSync(file, mode, options);
+    }, file, mode, options);
     promise.then((ret: NullishType): void => {
       let raffile = ret as RandomAccessFileInner;
       resolve(raffile);
@@ -1036,9 +959,12 @@ function createRandomAccessFile(file: string | File, mode?: number,
     });
   });
 }
+
 function fdopenStream(fd: number, mode: string): Promise<Stream> {
   return new Promise<Stream>((resolve: (result: Stream) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.fdopenStreamSync, fd, mode);
+    let promise = taskpool.execute((fd: number, mode: string): Stream => {
+      return FileIoImpl.fdopenStreamSync(fd, mode);
+    }, fd, mode);
     promise.then((ret: NullishType): void => {
       let stream = ret as Stream;
       resolve(stream);
@@ -1065,7 +991,9 @@ function setxattr(path: string, key: string, value: string): Promise<void> {
 }
 
 function createRandomAccessFile(file: string | File, callback: AsyncCallback<RandomAccessFile, void>): void {
-  let promise = taskpool.execute(FileIoImpl.createRandomAccessFileSync, file);
+  let promise = taskpool.execute((file: string | File): RandomAccessFile => {
+    return FileIoImpl.createRandomAccessFileSync(file);
+  }, file);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -1079,7 +1007,9 @@ function createRandomAccessFile(file: string | File, callback: AsyncCallback<Ran
 
 function createRandomAccessFile(file: string | File, mode: number,
   callback: AsyncCallback<RandomAccessFile, void>): void {
-  let promise = taskpool.execute(FileIoImpl.createRandomAccessFileSync, file, mode);
+  let promise = taskpool.execute((file: string | File, mode: number): RandomAccessFile => {
+    return FileIoImpl.createRandomAccessFileSync(file, mode);
+  }, file, mode);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -1092,7 +1022,9 @@ function createRandomAccessFile(file: string | File, mode: number,
 }
 
 function fdopenStream(fd: number, mode: string, callback: AsyncCallback<Stream>): void {
-  let promise = taskpool.execute(FileIoImpl.fdopenStreamSync, fd, mode);
+  let promise = taskpool.execute((fd: number, mode: string): Stream => {
+    return FileIoImpl.fdopenStreamSync(fd, mode);
+  }, fd, mode);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -1110,7 +1042,9 @@ function fdopenStreamSync(fd: number, mode: string): Stream {
 
 function createStream(path: string, mode: string): Promise<Stream> {
   return new Promise<Stream>((resolve: (result: Stream) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.createStreamSync, path, mode);
+    let promise = taskpool.execute((path: string, mode: string): Stream => {
+      return FileIoImpl.createStreamSync(path, mode);
+    }, path, mode);
     promise.then((ret: NullishType): void => {
       let stream = ret as Stream;
       resolve(stream);
@@ -1121,7 +1055,9 @@ function createStream(path: string, mode: string): Promise<Stream> {
 }
 
 function createStream(path: string, mode: string, callback: AsyncCallback<Stream>): void {
-  let promise = taskpool.execute(FileIoImpl.createStreamSync, path, mode);
+  let promise = taskpool.execute((path: string, mode: string): Stream => {
+    return FileIoImpl.createStreamSync(path, mode);
+  }, path, mode);
   promise.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     e.code = 0;
@@ -1172,7 +1108,9 @@ function lstatSync(path: string): Stat {
 
 function lstat(path: string): Promise<Stat> {
   return new Promise<Stat>((resolve: (result: Stat) => void, reject: (e: BusinessError<void>) => void) => {
-    let promise = taskpool.execute(FileIoImpl.lstatSync, path);
+    let promise = taskpool.execute((path: string): Stat => {
+      return FileIoImpl.lstatSync(path);
+    }, path);
     promise.then((ret: NullishType): void => {
       if (ret === null || ret === undefined) {
         let e = new BusinessError<void>();
@@ -1189,7 +1127,9 @@ function lstat(path: string): Promise<Stat> {
 }
 
 function lstat(path: string, callback: AsyncCallback<Stat, void>): void {
-  let p = taskpool.execute(FileIoImpl.lstatSync, path);
+  let p = taskpool.execute((path: string): Stat => {
+    return FileIoImpl.lstatSync(path);
+  }, path);
   p.then((ret: NullishType): void => {
     let e = new BusinessError<void>();
     if (ret === null || ret === undefined) {
@@ -1207,45 +1147,25 @@ function lstat(path: string, callback: AsyncCallback<Stat, void>): void {
 }
 function copyFile(src: string | number, dest: string | number, mode?: number): Promise<void> {
   return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
-    if (mode === undefined) {
-      let promise = taskpool.execute((src: string | number, dest: string | number): undefined =>
-        FileIoImpl.copyFileSync(src, dest), src, dest);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((src: string | number, dest: string | number, mode: number): undefined =>
-        FileIoImpl.copyFileSync(src, dest, mode), src, dest, mode);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((src: string | number, dest: string | number, mode?: number): undefined =>
+      FileIoImpl.copyFileSync(src, dest, mode), src, dest, mode);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
 function copy(srcUri: string, destUri: string, options?: CopyOptions): Promise<void> {
   return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
-    if (options === undefined) {
-      let promise = taskpool.execute((srcUri: string, destUri: string): undefined =>
-        FileIoImpl.copySync(srcUri, destUri), srcUri, destUri);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    } else {
-      let promise = taskpool.execute((srcUri: string, destUri: string, options: CopyOptions): undefined =>
-        FileIoImpl.copySync(srcUri, destUri, options), srcUri, destUri, options);
-      promise.then((ret: NullishType): void => {
-        resolve(undefined);
-      }).catch((e: BusinessError): void => {
-        reject(e);
-      });
-    }
+    let promise = taskpool.execute((srcUri: string, destUri: string, options?: CopyOptions): undefined =>
+      FileIoImpl.copySync(srcUri, destUri, options), srcUri, destUri, options);
+    promise.then((ret: NullishType): void => {
+      resolve(undefined);
+    }).catch((e: BusinessError): void => {
+      reject(e);
+    });
   });
 }
 
@@ -1421,7 +1341,7 @@ export class RandomAccessFileInner implements RandomAccessFile {
 
   writeSync(buffer: ArrayBuffer | string, options?: WriteOptions): number {
     let length = options ? this.writeSync0(buffer, options) : this.writeSync0(buffer);
-    this.filePointer += length;
+    this.filePointer += (options?.offset?? 0) + length;
     return length;
   }
 
@@ -1429,28 +1349,22 @@ export class RandomAccessFileInner implements RandomAccessFile {
 
   write(buffer: ArrayBuffer | string, options?: WriteOptions): Promise<number> {
     return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-      if (options === undefined) {
-        let promise = taskpool.execute(this.writeSync, buffer, options);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      } else {
-        let promise = taskpool.execute(this.writeSync, buffer, options);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      }
+      let promise = taskpool.execute((buffer: ArrayBuffer | string, options?: WriteOptions): number => {
+        return this.writeSync(buffer, options);
+      }, buffer, options);
+      promise.then((ret: NullishType): void => {
+        let result = ret as number
+        resolve(result);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
     });
   }
 
   write(buffer: ArrayBuffer | string, options: WriteOptions, callback: AsyncCallback<number, void>): void {
-    let promise = taskpool.execute(this.writeSync, buffer, options);
+    let promise = taskpool.execute((buffer: ArrayBuffer | string, options: WriteOptions): number => {
+      return this.writeSync(buffer, options);
+    }, buffer, options);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1462,7 +1376,9 @@ export class RandomAccessFileInner implements RandomAccessFile {
   }
 
   write(buffer: ArrayBuffer | string, callback: AsyncCallback<number, void>): void {
-    let promise = taskpool.execute(this.writeSync, buffer);
+    let promise = taskpool.execute((buffer: ArrayBuffer | string): number => {
+      return this.writeSync(buffer);
+    }, buffer);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1475,7 +1391,7 @@ export class RandomAccessFileInner implements RandomAccessFile {
 
   readSync(buffer: ArrayBuffer, options?: ReadOptions): number {
     const length = options ? this.readSync0(buffer, options) : this.readSync0(buffer);
-    this.filePointer += length;
+    this.filePointer += (options?.offset?? 0) + length;
     return length;
   }
 
@@ -1483,28 +1399,22 @@ export class RandomAccessFileInner implements RandomAccessFile {
 
   read(buffer: ArrayBuffer, options?: ReadOptions): Promise<number> {
     return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-      if (options === undefined) {
-        let promise = taskpool.execute(this.readSync, buffer);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number;
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      } else {
-        let promise = taskpool.execute(this.readSync, buffer, options);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number;
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      }
+      let promise = taskpool.execute((buffer: ArrayBuffer, options?: ReadOptions): number => {
+        return this.readSync(buffer, options);
+      }, buffer, options);
+      promise.then((ret: NullishType): void => {
+        let result = ret as number;
+        resolve(result);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
     });
   }
 
   read(buffer: ArrayBuffer, options: ReadOptions, callback: AsyncCallback<number, void>): void {
-    let promise = taskpool.execute(this.readSync, buffer, options);
+    let promise = taskpool.execute((buffer: ArrayBuffer, options: ReadOptions): number => {
+      return this.readSync(buffer, options);
+    }, buffer, options);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1516,7 +1426,9 @@ export class RandomAccessFileInner implements RandomAccessFile {
   }
 
   read(buffer: ArrayBuffer, callback: AsyncCallback<number, void>): void {
-    let promise = taskpool.execute(this.readSync, buffer);
+    let promise = taskpool.execute((buffer: ArrayBuffer): number => {
+      return this.readSync(buffer);
+    }, buffer);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1562,25 +1474,14 @@ export class FileInner implements File {
 
   lock(exclusive?: boolean): Promise<void> {
     return new Promise<void>((resolve: (result: undefined) => void, reject: (e: BusinessError<void>) => void): void => {
-      if (exclusive === undefined) {
-        let promise = taskpool.execute((): undefined => {
-          return this.lockSync();
-        });
-        promise.then((ret: NullishType): void => {
-          resolve(undefined);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      } else {
-        let promise = taskpool.execute((exclusive: boolean): undefined => {
-          return this.lockSync(exclusive);
-        }, exclusive);
-        promise.then((ret: NullishType): void => {
-          resolve(undefined);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      }
+      let promise = taskpool.execute((exclusive?: boolean): undefined => {
+        return this.lockSync(exclusive);
+      }, exclusive);
+      promise.then((ret: NullishType): void => {
+        resolve(undefined);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
     });
   }
 
@@ -1781,28 +1682,22 @@ export class StreamInner implements Stream {
 
   write(buffer: ArrayBuffer | string, options?: WriteOptions): Promise<number> {
     return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-      if (options === undefined) {
-        let promise = taskpool.execute(this.writeSync, buffer);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      } else {
-        let promise = taskpool.execute(this.writeSync, buffer, options);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      }
+      let promise = taskpool.execute((buffer: ArrayBuffer | string, options?: WriteOptions): number => {
+        return this.writeSync(buffer, options);
+      }, buffer, options);
+      promise.then((ret: NullishType): void => {
+        let result = ret as number
+        resolve(result);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
     });
   }
 
   write(buffer: ArrayBuffer | string, callback: AsyncCallback<number>): void {
-    let promise = taskpool.execute(this.writeSync, buffer);
+    let promise = taskpool.execute((buffer: ArrayBuffer | string): number => {
+      return this.writeSync(buffer);
+    }, buffer);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1814,7 +1709,9 @@ export class StreamInner implements Stream {
   }
 
   write(buffer: ArrayBuffer | string, options: WriteOptions, callback: AsyncCallback<number>): void {
-    let promise = taskpool.execute(this.writeSync, buffer, options);
+    let promise = taskpool.execute((buffer: ArrayBuffer | string, options: WriteOptions): number => {
+      return this.writeSync(buffer, options);
+    }, buffer, options);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1829,28 +1726,22 @@ export class StreamInner implements Stream {
 
   read(buffer: ArrayBuffer, options?: ReadOptions): Promise<number> {
     return new Promise<number>((resolve: (result: number) => void, reject: (e: BusinessError<void>) => void) => {
-      if (options === undefined) {
-        let promise = taskpool.execute(this.readSync, buffer);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      } else {
-        let promise = taskpool.execute(this.readSync, buffer, options);
-        promise.then((ret: NullishType): void => {
-          let result = ret as number
-          resolve(result);
-        }).catch((e: BusinessError): void => {
-          reject(e);
-        });
-      }
+      let promise = taskpool.execute((buffer: ArrayBuffer, options?: ReadOptions): number => {
+        return this.readSync(buffer, options);
+      }, buffer, options);
+      promise.then((ret: NullishType): void => {
+        let result = ret as number
+        resolve(result);
+      }).catch((e: BusinessError): void => {
+        reject(e);
+      });
     });
   }
 
   read(buffer: ArrayBuffer, callback: AsyncCallback<number>): void {
-    let promise = taskpool.execute(this.readSync, buffer);
+    let promise = taskpool.execute((buffer: ArrayBuffer): number => {
+      return this.readSync(buffer);
+    }, buffer);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;
@@ -1862,7 +1753,9 @@ export class StreamInner implements Stream {
   }
 
   read(buffer: ArrayBuffer, options: ReadOptions, callback: AsyncCallback<number>): void {
-    let promise = taskpool.execute(this.readSync, buffer, options);
+    let promise = taskpool.execute((buffer: ArrayBuffer, options: ReadOptions): number => {
+      return this.readSync(buffer, options);
+    }, buffer, options);
     promise.then((ret: NullishType): void => {
       let e = new BusinessError<void>();
       e.code = 0;