java - 递归嵌套目录中的多线程，同时删除它

Question

1. 我正在尝试删除一个非常大的嵌套目录结构，其中包含多个文件和子目录。每个子目录里面可以有多个文件和子目录。

2. 所以我们这里只能删除一个文件或者一个空目录。如果目录不为空并且有更多文件和子目录，则列出这些子目录和文件并递归删除它们。

3. 我在这里写了一个伪代码，并使用并行流递归删除列表。

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);

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

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

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

标签： javamultithreadingrecursionparallel-processingjava-8