java fork/join 框架实现的快速排序(纯属娱乐)

package org.xlj.threads;

import java.util.*;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

public class ForkJoinUseCase {

    // test
    public static void main(String[] args) {

        ForkJoinPool forkJoinPool = new ForkJoinPool();

        List<Integer> listTmeps = new ArrayList<>();

        int count = 10000 * 1000;

        for (int i = count; i > 0; i--) {
            listTmeps.add((int) (Math.random() * count));
        }

        long tick = System.currentTimeMillis();
        OrderTask task = new OrderTask(0, listTmeps.size() - 1, listTmeps);
        forkJoinPool.submit(task);
        task.join();
        tick = System.currentTimeMillis() - tick;
//        System.out.println("listTmeps: " + listTmeps);
        System.out.println("tick: " + tick);
        System.out.println("task.isCompletedAbnormally: " + task.isCompletedAbnormally());
        System.out.println("task.getException: " + task.getException());

        // checked, there are any unqualified numbers.
        for (int i = 0; i < listTmeps.size(); i++) {
            if (i != 0) {
                if (listTmeps.get(i) < listTmeps.get(i - 1)) {
                    System.out.println(listTmeps.get(i) + " < " + listTmeps.get(i - 1));
                    System.out.println("error");
                    break;
                }
            }
        }

    }

    public static class OrderTask extends RecursiveTask<Integer> {
//        private static final int THRESHOLD = 2;

        private int startIndex = 0;
        private int endIndex = 0;

        List<Integer> list = null;

        public OrderTask(int startIndex, int endIndex, List<Integer> list) {
            this.startIndex = startIndex;
            this.endIndex = endIndex;
            this.list = list;
        }

        @Override
        protected Integer compute() {
            int middleIndex = (int) ((this.endIndex - this.startIndex) / 2) + this.startIndex;
            int middleValue = this.list.get(middleIndex);
            this.list.set(middleIndex, list.get(startIndex));
            int startIndex = this.startIndex;
            int endIndex = this.endIndex;

            while (startIndex < endIndex) {
                while (startIndex < endIndex && this.list.get(endIndex) >= middleValue) {
                    endIndex--;
                }

                // do not swap, it was changed directly
                this.list.set(startIndex, this.list.get(endIndex));

                while (startIndex < endIndex && this.list.get(startIndex) < middleValue) {
                    startIndex++;
                }

                // do not swap, it was changed directly
                this.list.set(endIndex, this.list.get(startIndex));
            }

            this.list.set(startIndex, middleValue);
            if(startIndex != endIndex ) {
                System.out.println(startIndex + " != " + endIndex);
            }

            OrderTask taskLeft = null;
            OrderTask taskRight = null;

            // there are at least two numbers
            if ((startIndex - 1) - this.startIndex >= 1) {
                taskLeft = new OrderTask(this.startIndex, startIndex - 1, this.list);
                taskLeft.fork();
            }

            // there are at least two numbers
            if (this.endIndex - (startIndex + 1) >= 1) {
                taskRight = new OrderTask(startIndex + 1, this.endIndex, this.list);
                taskRight.fork();
            }

            if (taskLeft != null) {
                taskLeft.join();
            }
            if (taskRight != null) {
                taskRight.join();
            }

            return null;
        }
    }

}