没有线程重叠的带有MultiThreading的调度MultiThreading

Question

我有5个参数化线程指向5个文件夹，其中参数将是文件夹的名称。假设FolderNames是A，B，C，D和E。

每个文件夹将有多个文件，需要对这些文件执行某些操作。

对每个文件夹下的所有文件执行的操作将是相同的，即任务将是相同的。这整件事需要不断地运行，也就是说，它必须在一个时间表里。

我尝试过的事情：

1. 使用MultiThreading (即，在同一个任务上工作的5个参数化线程)调度，但这将导致线程的重叠，因为任务是常见的，并且不会生成所需的输出。
2. 使用MultiTasking调度，即为实现Runnable的每个文件夹创建一个单独的类，并对每个类使用executor.scheduleAtFixedRate。这将导致同步操作，这意味着在第一个文件夹上的操作尚未结束之前，其他4个文件夹的处理不会启动。我们不能在corePoolSize中增加newScheduledThreadPool，因为它会产生与第1点相同的重叠问题。

因此，我正在寻找帮助，以解决这个问题，我的线程不重叠的基础任务。

图文形式的上述问题综述

场景2的虚拟代码：

class FolderA implements Runnable{
    private final String fileName;

    FolderA(String fileName){
        this.fileName=fileName;
    }
    @Override
    public void run() {
        ScheduleJob.insideRun(fileName);
    }
}

class FolderB implements Runnable{...}
class FolderC implements Runnable{...}
class FolderD implements Runnable{...}
class FolderE implements Runnable{...}

public class ScheduleJob{
    ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    
    FolderA folderA = new FolderA("folderA");
    executor.scheduleAtFixedRate(folderA, 60,60, TimeUnit.SECONDS);
    
    FolderB folderB = new FolderB("folderB");
    executor.scheduleAtFixedRate(folderB, 60,60, TimeUnit.SECONDS);
    
    --and same for Folder  C D and E
    
     public static void insideRun(String folderName){
     
     //Contains call to various operations that need to 
     be perfomed on each file present in Folder A B C D and E
     
     Operation order : Read, Process, Write for each file
     
     }
    
    
}

Answer 1

您的问题不清楚，但我猜您希望一个文件夹中的文件处理不妨碍或阻止其他文件夹中的文件处理。

多个ExecutorService对象

创建多个ExecutorService对象。每个executor服务都集中在一个文件夹上。如果您有五个文件夹，则有五个执行器服务，每个文件夹有一个执行器服务。

如果希望一次只处理每个文件夹一个文件，则使每个executor服务都是单线程的。

将任务( Runnable或Callable)定义为接受指示要处理哪个文件夹的参数。

public void FileProcessor implements Runnable
{
    // Constructor
    public FileProcessor( Path path ) { … } 

    // Implement `Runnable`
    @Override
    public void run() { … }
} 

定义你的文件夹。

List< Path > folders = List.of( pathToA, pathToB, … ) ;

将它们传递给executor服务的构造函数。

List< ExecutorService > executorServices = new ArrayList<>() ;
for( Path folder : folders )
{
    ExecutorService es = Executors. newSingleThreadExecutor() ;
    executorServices.add( es ) ;
    es.submit( new FileProcessor( folder ) ) ;
}

然后使用集合executorServices优雅地关闭所有执行器服务。

对于预定的执行者服务，同样的想法。将类型从ExecutorService更改为ScheduledExecutorService。打给Executors.newSingleThreadScheduledExecutor。将submit方法更改为调度方法之一。

请注意，即使是在这个答案中提出的解决方案也不能保证所有文件夹都会以相同的努力处理。每个执行者服务都将由自己的线程支持。当一个线程被安排在CPU内核上执行，以及执行时间多长时，这取决于主机OS和JVM的一时兴起。

作为Java程序员，我们无法直接控制每个线程所执行的工作量或顺序。在运行时，完全有可能文件夹B可能处理十几个文件，而文件夹A只处理三个文件，而文件夹C没有完成。一般来说，随着时间的推移，你会看到工作的平均值，但短期内可能会有所不同。