ForkJoinPool - 为什么程序抛出OutOfMemoryError？

Question

我想在Java 8中试用ForkJoinPool，所以我编写了一个小程序，用于搜索名称中包含给定目录中特定关键字的所有文件。

计划 ：

public class DirectoryService {

    public static void main(String[] args) {
        FileSearchRecursiveTask task = new FileSearchRecursiveTask("./DIR");
        ForkJoinPool pool = (ForkJoinPool) Executors.newWorkStealingPool();
        List<String> files = pool.invoke(task);
        pool.shutdown();
        System.out.println("Total  no of files with hello" + files.size());
    }

}

    class FileSearchRecursiveTask extends RecursiveTask<List<String>> {
        private String path;
        public FileSearchRecursiveTask(String path) {
            this.path = path;
        }

        @Override
        protected List<String> compute() {
            File mainDirectory = new File(path);
            List<String> filetedFileList = new ArrayList<>();
            List<FileSearchRecursiveTask> recursiveTasks = new ArrayList<>();
            if(mainDirectory.isDirectory()) {
                System.out.println(Thread.currentThread() + " - Directory is " + mainDirectory.getName());
                if(mainDirectory.canRead()) {
                    File[] fileList = mainDirectory.listFiles();
                    for(File file : fileList) {
                        System.out.println(Thread.currentThread() + "Looking into:" + file.getAbsolutePath());
                        if(file.isDirectory()) {
                            FileSearchRecursiveTask task = new FileSearchRecursiveTask(file.getAbsolutePath());
                            recursiveTasks.add(task);
                            task.fork();
                        } else {
                            if (file.getName().contains("hello")) {
                                System.out.println(file.getName());
                                filetedFileList.add(file.getName());
                            }
                        }
                    }
                }

                for(FileSearchRecursiveTask task : recursiveTasks) {
                  filetedFileList.addAll(task.join());
                }

        }
        return filetedFileList;

    }
}

当目录没有太多的子目录和文件时，这个程序工作正常，但如果它真的很大，那么抛出OutOfMemoryError。

我的理解是最大线程数（包括补偿线程）是有界限的，为什么它们是这个错误？ 我在程序中遗漏了什么吗？

Caused by: java.lang.OutOfMemoryError: unable to create new native thread
at java.lang.Thread.start0(Native Method)
at java.lang.Thread.start(Thread.java:714)
at java.util.concurrent.ForkJoinPool.createWorker(ForkJoinPool.java:1486)
at java.util.concurrent.ForkJoinPool.tryCompensate(ForkJoinPool.java:2020)
at java.util.concurrent.ForkJoinPool.awaitJoin(ForkJoinPool.java:2057)
at java.util.concurrent.ForkJoinTask.doJoin(ForkJoinTask.java:390)
at java.util.concurrent.ForkJoinTask.join(ForkJoinTask.java:719)
at FileSearchRecursiveTask.compute(DirectoryService.java:51)
at FileSearchRecursiveTask.compute(DirectoryService.java:20)
at java.util.concurrent.RecursiveTask.exec(RecursiveTask.java:94)
at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)
at java.util.concurrent.ForkJoinPool$WorkQueue.tryRemoveAndExec(ForkJoinPool.java:1107)
at java.util.concurrent.ForkJoinPool.awaitJoin(ForkJoinPool.java:2046)
at java.util.concurrent.ForkJoinTask.doJoin(ForkJoinTask.java:390)
at java.util.concurrent.ForkJoinTask.join(ForkJoinTask.java:719)
at FileSearchRecursiveTask.compute(DirectoryService.java:51)
at FileSearchRecursiveTask.compute(DirectoryService.java:20)
at java.util.concurrent.RecursiveTask.exec(RecursiveTask.java:94)
at java.util.concurrent.ForkJoinTask.doExec(ForkJoinTask.java:289)   

Answer 1

你不应该将新任务分散到所有认可之外。 基本上，只要有可能另一个工作线程可以获取分叉作业并在本地进行评估，您应该进行分叉。 然后，一旦你分叉了一个任务，就不要在之后调用join() 。 虽然底层框架将启动补偿线程以确保您的作业将继续而不是仅阻止所有线程等待子任务，但这将创建可能超出系统功能的大量线程。

这是您的代码的修订版本：

public class DirectoryService {

    public static void main(String[] args) {
        FileSearchRecursiveTask task = new FileSearchRecursiveTask(new File("./DIR"));
        List<String> files = task.invoke();
        System.out.println("Total no of files with hello " + files.size());
    }

}

class FileSearchRecursiveTask extends RecursiveTask<List<String>> {
    private static final int TARGET_SURPLUS = 3;
    private File path;
    public FileSearchRecursiveTask(File file) {
        this.path = file;
    }

    @Override
    protected List<String> compute() {
        File directory = path;
        if(directory.isDirectory() && directory.canRead()) {
            System.out.println(Thread.currentThread() + " - Directory is " + directory.getName());
            return scan(directory);
        }
        return Collections.emptyList();
    }

    private List<String> scan(File directory)
    {
        File[] fileList = directory.listFiles();
        if(fileList == null || fileList.length == 0) return Collections.emptyList();
        List<FileSearchRecursiveTask> recursiveTasks = new ArrayList<>();
        List<String> filteredFileList = new ArrayList<>();
        for(File file: fileList) {
            System.out.println(Thread.currentThread() + "Looking into:" + file.getAbsolutePath());
            if(file.isDirectory())
            {
                if(getSurplusQueuedTaskCount() < TARGET_SURPLUS)
                {
                    FileSearchRecursiveTask task = new FileSearchRecursiveTask(file);
                    recursiveTasks.add(task);
                    task.fork();
                }
                else filteredFileList.addAll(scan(file));
            }
            else if(file.getName().contains("hello")) {
                filteredFileList.add(file.getAbsolutePath());
            }
        }

        for(int ix = recursiveTasks.size() - 1; ix >= 0; ix--) {
            FileSearchRecursiveTask task = recursiveTasks.get(ix);
            if(task.tryUnfork()) task.complete(scan(task.path));
        }

        for(FileSearchRecursiveTask task: recursiveTasks) {
            filteredFileList.addAll(task.join());
        }
        return filteredFileList;
    }
}

执行处理的方法已经被分解为接收目录作为参数的方法，因此我们能够在本地使用它来获取不一定与FileSearchRecursiveTask实例相关联的任意目录。

然后，该方法使用getSurplusQueuedTaskCount()来确定其他工作线程尚未获取的本地排队任务的数量。 确保有一些帮助平衡工作。 但是，如果此数字超过阈值，则处理将在本地完成，而不需要更多的工作。

在本地处理之后，它迭代任务并使用tryUnfork()来识别未被其他工作线程窃取并在本地处理它们的作业。 对最年轻的工作进行反复尝试可以提高找到一些工作的机会。

只有在此之后，它才会join() s所有子作业，这些子作业现在由另一个工作线程完成或者当前处理。

请注意，我更改了启动代码以使用默认池。 这使用“CPU核心数”减去一个工作线程，加上初始化线程，即本例中的main线程。

Answer 2

只需稍作修改即可。 您需要为newWorkStealingPool指定并行度，如下所示：

ForkJoinPool pool = (ForkJoinPool) Executors.newWorkStealingPool(5);

根据其文件：

newWorkStealingPool（int parallelism） - >创建一个线程池，维护足够的线程以支持给定的并行级别，并可以使用多个队列来减少争用。 并行度级别对应于主动参与或可用于任务处理的最大线程数。 实际线程数可能会动态增长和缩小。 工作窃取池不保证提交任务的执行顺序。

根据附带的Java Visual VM屏幕截图，这种并行性允许程序在指定的内存中工作，永远不会耗尽内存。

而且，还有一件事（不确定它是否会产生任何影响）：

更改调用fork的顺序，并将任务添加到列表中。 也就是说，改变

FileSearchRecursiveTask task = new FileSearchRecursiveTask(file.getAbsolutePath());
recursiveTasks.add(task);
task.fork();

至

FileSearchRecursiveTask task = new FileSearchRecursiveTask(file.getAbsolutePath());
task.fork();
recursiveTasks.add(task);