Comparing Fork And Join with Single threaded program

Question

I am trying to get started with the Fork-Join framework for a smaller task. As I start-up example I tried copying mp3 files

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class DeepFileCopier extends RecursiveTask<String>{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private static Path startingDir = Paths.get("D:\\larsen\\Music\\");
    private static List<Path> listOfPaths = new ArrayList<>();
    private int start, end;

    public static void main(String[] args) throws IOException
    {
        long startMillis = System.currentTimeMillis();
        Files.walkFileTree(startingDir, new CustomFileVisitor());
        final DeepFileCopier deepFileCopier = new DeepFileCopier(0,listOfPaths.size());
        final ForkJoinPool pool = new ForkJoinPool(Runtime.getRuntime().availableProcessors());
        pool.invoke(deepFileCopier);
        System.out.println("With Fork-Join " + (System.currentTimeMillis() - startMillis));
        long secondStartMillis = System.currentTimeMillis();
        deepFileCopier.start = 0;
        deepFileCopier.end = listOfPaths.size();
        deepFileCopier.computeDirectly();
        System.out.println("Without Fork-Join " + (System.currentTimeMillis() - secondStartMillis));

    }

    private static class CustomFileVisitor extends SimpleFileVisitor<Path> {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException
        {
            if (file.toString().endsWith(".mp3")) {
                listOfPaths.add(file);
            }
            return FileVisitResult.CONTINUE;
        }
    }

    @Override
    protected String compute() {
        int length = end-start;
        if(length < 4) {
            return computeDirectly();
        }
        int split = length / 2;
        final DeepFileCopier firstHalfCopier = new DeepFileCopier(start, start + split);
        firstHalfCopier.fork();
        final DeepFileCopier secondHalfCopier = new DeepFileCopier(start + split, end);
        secondHalfCopier.compute();
        firstHalfCopier.join();
        return null;
    }

    private String computeDirectly() {
        for(int index = start; index< end; index++) {
            Path currentFile = listOfPaths.get(index);
            System.out.println("Copying :: " + currentFile.getFileName()); 
            Path targetDir = Paths.get("D:\\Fork-Join Test\\" + currentFile.getFileName());
            try {
                Files.copy(currentFile, targetDir, StandardCopyOption.REPLACE_EXISTING);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    private DeepFileCopier(int start, int end ) {
        this.start = start;
        this.end = end;
    }

}

On comparing the performance I noticed -

With Fork-Join 149714 Without Fork-Join 146590

Am working on a Dual Core machine. I was expecting a 50% reduction in the work time but the portion with Fork-Join takes 3 seconds more than a single threaded approach. Please let me know if some thing is incorrect.

Answer 1

Your problem is not well suited to benefit from multithreading on normal systems. The execution time is spent copying all the files. But this is limited by your hard drive that will process the files in sequence.

If you run a more CPU intense task, you should note a difference. For test purposes you could try the following:

private String computeDirectly() {
   Integer nonsense;
   for(int index = start; index< end; index++) {
      for( int j = 0; j < 1000000; j++ )
         nonsense += index*j;
    }
    return nonsense.toString();
}

On my system (i5-2410M) this will print:

With Fork-Join 2628
Without Fork-Join 6421