Чтение файла через ForkJoinPool

    public void parseFile() {
        ForkJoinPool pool = new ForkJoinPool(4);
        FileParserProcessor fileParser = new FileParserProcessor("MyBigFile.txt", 24);
        pool.invoke(fileParser);
        pool.shutdown();
    }

public class FileParserProcessor extends RecursiveAction {
    private long workLoad = 0;
    private String path;
 
    public FileParserProcessor(String path, long workLoad) {
        this.workLoad = workLoad;
        this.path = path;
    }
 
 
    @Override
    protected void compute() {
        //if work is above threshold, break tasks up into smaller tasks
        if(this.workLoad > 16) {
 
            List<FileParserProcessor> subtasks =
                    new ArrayList<FileParserProcessor>(createSubtasks());
 
            for(RecursiveAction subtask : subtasks){
                subtask.fork();
            }
 
        } else {
            try (BufferedReader br = new BufferedReader(
                    // TODO: to make file upload via interface
                    new FileReader(path)
            )) {
                String line;
                while ((line = br.readLine()) != null) {
                    System.out.println(line);
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException("An error occurred: file not found", e);
            } catch (IOException e) {
                throw new RuntimeException("An error occurred while parsing file", e);
            }
        }
    }
 
    private List<FileParserProcessor> createSubtasks() {
        List<FileParserProcessor> subtasks =
                new ArrayList<FileParserProcessor>();
 
        FileParserProcessor subtask1 = new FileParserProcessor(path, this.workLoad / 2);
        FileParserProcessor subtask2 = new FileParserProcessor(path, this.workLoad / 2);
 
        subtasks.add(subtask1);
        subtasks.add(subtask2);
 
        return subtasks;
    }
}

    public void parseFile() {
        final int threadCount = Runtime.getRuntime().availableProcessors();
        BlockingQueue<String> queue = new ArrayBlockingQueue<String>(2000000);
        // create thread pool with given size
        ExecutorService service = Executors.newFixedThreadPool(threadCount);
        for (int i = 0; i < (threadCount - 1); i++) {
                service.submit(new CPUTask(queue));
        }
        // Wait til FileTask completes
        try {
            service.submit(new FileTask(queue)).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException("An error .......................................", e);
        }
        service.shutdownNow();  // interrupt CPUTasks
        // Wait til CPUTasks terminate
        try {
            service.awaitTermination(5, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
            throw new RuntimeException("An error occurred when terminate parsing process by timeout", e);
        }
    }
 
    class CPUTask implements Runnable {
        private final BlockingQueue<String> queue;
 
        public CPUTask(BlockingQueue<String> queue) {
            this.queue = queue;
        }
 
        public void run() {
            String line;
 
            while (true) {
                try {
                    // block if the queue is empty
                    line = queue.take();
 
                    System.out.println(line);
 
                    // do things with line
                } catch (InterruptedException ex) {
                    break; // FileTask has completed
                }
            }
        }
    }
 
    class FileTask implements Runnable {
        private final BlockingQueue<String> queue;
 
        public FileTask(BlockingQueue<String> queue) {
            this.queue = queue;
        }
 
        public void run() {
            try (BufferedReader br = new BufferedReader(
                    // TODO: to make file upload via interface
                    new FileReader("MyVeryBigFile.txt")
            )) {
                String line;
                while ((line = br.readLine()) != null) {
                    // block if the queue is full
                    queue.put(line);
                }
            } catch (FileNotFoundException e) {
                throw new RuntimeException("An error occurred: file not found", e);
            } catch (IOException | InterruptedException e) {
                throw new RuntimeException("An error occurred while parsing file", e);
            }
        }
    }

    public void parseFile() {
        try {
            Stream<String> lines = Files.lines(Paths.get("MyBigFile.txt"));
            lines.parallel()
                    .forEach(System.out::println);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }