ForkJoinPool与普通递归

Question

在阅读了关于ForkJoinPool的文章之后，我尝试了一个实验，测试与普通递归相比，ForkJoinPool实际上有多快。

我以递归的方式计算了文件夹中的文件数，令我满意的是，简单的递归比forkjoinpool执行得更好

这是我的密码。

递归任务

class DirectoryTask extends RecursiveTask<Long> {

    private Directory directory;

    @Override
    protected Long compute() {
        List<RecursiveTask<Long>> forks = new ArrayList<>();
        List<Directory> directories = directory.getDirectories();
        for (Directory directory : directories) {
            DirectoryTask directoryTask = new DirectoryTask(directory);
            forks.add(directoryTask);
            directoryTask.fork();
        }
        Long count = directory.getDoumentCount();
        for (RecursiveTask<Long> task : forks) {
            count += task.join();
        }
        return count;
    }
}

纯递归

private static Long getFileCount(Directory directory) {
        Long recursiveCount = 0L;
        List<Directory> directories = directory.getDirectories();
        if (null != directories) {
            for (Directory d : directories) {
                recursiveCount += getFileCount(d);
            }
        }
        return recursiveCount + directory.getDoumentCount();
    }

class Directory {

    private List<Directory> directories;
    private Long doumentCount = 0L;

    static Directory fromFolder(File file) {
        List<Directory> children = new ArrayList<>();
        Long documentCount = 0L;
        if (!file.isDirectory()) {
            throw new IllegalArgumentException("Only directories are allowed");
        }
        String[] files = file.list();
        if (null != files) {
            for (String path : files) {
                File f = new File(file.getPath() + File.separator + path);
                if (f.isHidden()) {
                    continue;
                }
                if (f.isDirectory()) {
                    children.add(Directory.fromFolder(f));
                } else {
                    documentCount++;
                }
            }
        }
        return new Directory(children, documentCount);
    }
}

null

Answer 1

生活中没有什么是免费的。如果你必须把一个啤酒板条箱从你的车搬到你的公寓--什么更快：手动把它搬到那里，还是先去小屋，让独轮车用它来搬那一个板条箱？

创建线程对象是一个“本机”操作，它进入底层操作系统以获取那里的资源。这可能是一个相当昂贵的行动。

意思是：仅仅在一个问题上抛出“更多的线程”并不能自动加快速度。恰恰相反。当您的任务主要是CPU密集型的时候，并行处理可能会有很小的收益。当您正在执行大量IO时，那么拥有多个线程可以让您在总体上“少”等待；从而提高吞吐量。

为了进一步阅读，您可以查看并行流。它们使用Fork/Join框架；令人惊讶的是，期望任意ParallelStream也比普通流“快”是一个错误的概念。