Question

我正在尝试删除一个很大的嵌套目录结构，其中包含多个文件和子目录。每个子目录中可以包含多个文件和子目录。



所以我们只能在这里删除文件或空目录。如果目录不为空并且包含其他文件和子目录，请列出这些子目录和文件并递归删除它们。



我在这里编写了伪代码，并使用并行流来递归删除列表。

class A {
    boolean mainDeletemethod(obj){
        boolean finalStatus = false;
          if(obj.type == file){
             deleteAPI(obj);
              finalStatus = true;
          } //if ends
          else if(obj.type==directory){
             if(obj.message.recursive == true) { //inner if
                boolean status =   deleteDirectoryAPI(obj)
                   if(!status)
                      return status
                } //inner if ends
             else{ // empty directory, delete it, deleteDir would take care of that, inner else loop 
                   deleteDir(obj)
                      finalStatus = true;
                 } //inner else ends
          }//else if ends
    return finalStatus;
    } //mainDeletemethod ends

    boolean deleteDirectoryAPI(Object obj){
            list<Object> results = listAPI(obj) //results would have subdirectories and files inside it
    //trying to parallelize the deletion of files and directory
        boolean stat =result
                    .stream()
                    .parallel()
                    .map(fileObject -> {
                        boolean individualStatus = null;
                        try {
                            individualStatus = deleteParallel(obj);
                        } catch (Exception e) {
                            _log.error("Error", e);
                            return individualStatus;
                        }
                        return true;
                    })
                    .filter(status-> status != true)
                    .findFirst()
                    .orElse(Status.OK);

        if(stat!=true){
            return stat;
        }
    } // deleteDirectoryAPI ends


    boolean deleteParallel(obj) {
        boolean status = mainDeletemethod(obj);
        if(status)
            return status;
        return false; 
    } //deleteParallel ends

} //Class A ends

我在这段代码中遇到了一些问题

.filter(status-> status != true)
            .findFirst()
            .orElse(Status.OK);

上面的代码使流等待所有子任务完成。它将线程保存在默认执行程序中。当执行器中的所有线程都按递归调用顺序在这里等待而用尽时，会卡住吗？



我想这使我的父任务等待所有子任务（在递归的情况下，在这种情况下，我们具有较深的目录/文件结构）要等待，并且可能导致死锁，以防线程池耗尽。我的线程池可以在这里用尽吗？


我不想等待单个递归子任务返回状态并检查状态，而是想通过某个全局Atomic变量来实现它，如果我的任何子任务失败并返回该变量，则将其设置为false。我可能有多个删除任务，因此这里需要一个“原子映射”变量，该变量可以跟踪所有计划的任务。

递归嵌套目录中的多线程删除时

0 个答案: