java分治思想之ForkJoin怎麼應用

分治思想演算法

fork-join模式是基於分治思想的平行計算模式之一。此模式將一個大的任務分割成多個小的子任務，然後並行執行這些子任務，最後將它們的結果合併起來得到最終的結果。在這個過程中，每個子任務的執行可以進一步分解為更小的子任務，直到達到某個閾值，這時候任務將被串列執行。這種遞歸的分治思想使得fork-join模式可以有效地利用電腦的多核心處理能力，從而提高程式的效能和效率。

歸併排序

歸併排序是一種基於分治思想的排序演算法。其核心思想是將一個數組分成兩個子數組，分別對其進行排序後再將其合併起來。具體實作過程如下：

• 分解：將一個陣列分成兩個子數組，分別將其排序。可以使用遞歸來實現這一步驟。

• 合併：將排序後的兩個子數組合成一個有順序的陣列。

• 遞歸：將兩個子數組遞歸進行分解和排序，直到每個子數組的長度為1。

時間複雜度為O(nlogn)。

public class Merge {
    public static void main(String[] args) {
        int[] arr = { 5, 2, 8, 4, 7, 1, 3, 6 };
        mergeSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
    /**
     * 拆分
     * @param arr 数组
     * @param left 数组第一个元素
     * @param right 数组最后一个元素
     */
    public static void mergeSort(int[] arr,int left,int right){
        if (left < right) {
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid);
            mergeSort(arr, mid + 1, right);
            merge(arr, left, mid, right);
        }
    }
    /**
     * 合并
     * @param arr 数组
     * @param left 数组第一个元素
     * @param mid 数组分割的元素
     * @param right 数组最后一个元素
     */
    public static void merge(int[] arr,int left,int mid,int right){
        //创建临时数组，用于存放合并后的数组
        int[] temp = new int[right - left + 1];
        //左面数组的起始指针
        int i = left;
        //右面数组的起始指针
        int j = mid + 1;
        //临时数组的下标
        int k = 0;
        //数组左面和数组右面都还有值就去遍历比较赋值
        while (i <= mid && j <= right) {
            //数组左面的值小于或者等于数组右面的值就把左面的值赋值到临时数组中
            //并且把左面的指针和临时数组的指针+1
            //否则相反
            if (arr[i] <= arr[j]) {
                temp[k] = arr[i];
                k++;
                i++;
            } else {
                temp[k] = arr[j];
                k++;
                j++;
            }
        }
        //把剩余数组塞进去
        while (i <= mid) {
            temp[k] = arr[i];
            k++;
            i++;
        }
        while (j <= right) {
            temp[k] = arr[j];
            k++;
            j++;
        }
        //讲临时数组中的元素拷贝会回原数组中
        for (int p = 0; p < temp.length; p++) {
            arr[left + p] = temp[p];
        }
    }
}

快速排序

快速排序（Quick Sort）是一種基於分治思想的排序演算法，它採用了遞歸的方式將一個大的數組分解成多個子數組，分別排序後再將它們合併起來。其基本思想是選取一個基準元素，將數組中小於該元素的值放在左邊，大於該元素的值放在右邊，然後遞歸地對左右兩個子數組進行排序。具體的步驟如下：

• 選取一個基準元素（通常是陣列中的第一個元素）。

• 將陣列中小於該元素的值放在左邊，大於該元素的值放在右邊。

• 對左右兩個子陣列分別遞歸進行快速排序。

• 合併左右兩個已排序的子陣列。

快速排序的時間複雜度為O(nlogn)，它是一種原地排序演算法，不需要額外的儲存空間，因此空間複雜度為O(1)。雖然快速排序的最壞時間複雜度為O(n^2)，但是在實際應用中，快速排序的平均時間複雜度和最好時間複雜度均為O(nlogn)，因此是一種非常高效的排序演算法

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = { 5, 2, 8, 4, 7, 1, 3, 6 };
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
    public static void quickSort(int[] arr,int left,int right){
        if(left<right){
            int pivotIndex  = partition(arr, left, right);
            quickSort(arr,left,pivotIndex-1);
            quickSort(arr,pivotIndex+1,right);
        }
    }
    public static int partition(int[] arr,int left,int right){
        //取第一个元素为基准元素
        int pivot = arr[left];
        int i = left+1;
        int j = right;
        while (i<=j){
            //当前指针位置数小于基准元素就继续移动指针直到遇到大的
            while (i<=j && arr[i] < pivot){
                i++;
            }
            //当前指针位置数大于基准元素就继续移动指针直到遇到小的
            while (i<=j && arr[j] > pivot){
                j--;
            }
            if(i<j){
                //交换元素位置
                swap(arr,i,j);
                i++;
                j--;
            }
        }
        //跳出循环说明i和j相遇,j的值一定是大于基准元素,要和基准元素进行交换
        swap(arr,left,j);
        //返回基准元素位置
        return j;
    }
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

Fork/Join

#Fork/Join框架的主要組成部分是ForkJoinPool、ForkJoinTask。 ForkJoinPool是一個執行緒池，它用來管理ForkJoin任務的執行。 ForkJoinTask是一個抽象類別，用來表示可以分割成更小部分的任務。

ForkJoinPool

ForkJoinPool是Fork/Join框架中的執行緒池類，它用於管理Fork/Join任務的執行緒。 ForkJoinPool類別包含一些重要的方法，例如submit()、invoke()、shutdown()、awaitTermination()等，用於提交任務、執行任務、關閉執行緒池和等待任務的執行結果。 ForkJoinPool類別中也包含一些參數，例如執行緒池的大小、工作執行緒的優先權、任務佇列的容量等，可以根據特定的應用場景進行設定。

建構器

ForkJoinPool中有四個核心參數，用於控制執行緒池的平行數、工作執行緒的建立、異常處理和模式指定等。

• int parallelism：指定並行層級（parallelism level）。 ForkJoinPool將根據這個設定，決定工作執行緒的數量。如果未設定的話，將使用Runtime.getRuntime().availableProcessors()來設定並行層級；

• ForkJoinWorkerThreadFactory factory：ForkJoinPool在建立執行緒時，會透過factory來建立。注意，這裡需要實作的是ForkJoinWorkerThreadFactory，而不是ThreadFactory。如果你不指定factory，那麼將由預設的DefaultForkJoinWorkerThreadFactory負責執行緒的建立工作；

• UncaughtExceptionHandler handler：指定例外處理器，當任務在執行中出錯時，將由設定的處理器處理；

• boolean asyncMode：設定佇列的工作模式。當asyncMode為true時，將使用先進先出佇列，而為false時則使用後進先出的模式。

工作竊取法

在Fork-Join模式中，任務被指派給一個執行緒池中的工作執行緒來執行。當一個工作執行緒執行完自己指派的任務後，它可以從其他工作執行緒的任務佇列中偷取（Steal）任務來執行，這就是所謂的工作竊取（Work Stealing）。

使用

public class SumTask extends RecursiveTask<Integer> {
    private static final int THRESHOLD = 1000;
    private int[] array;
    private int start;
    private int end;
    public SumTask(int[] array, int start, int end) {
        this.array = array;
        this.start = start;
        this.end = end;
    }
    @Override
    protected Integer compute() {
        if (end - start <= THRESHOLD) {
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(array, start, mid);
            SumTask rightTask = new SumTask(array, mid, end);
            leftTask.fork();
            rightTask.fork();
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();
            return leftResult + rightResult;
        }
    }
    public static void main(String[] args) {
        int[] array = new int[10000];
        for (int i = 0; i < array.length; i++) {
            array[i] = i + 1;
        }
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        SumTask task = new SumTask(array, 0, array.length);
        int result = forkJoinPool.invoke(task);
        System.out.println(result);
    }
}

以上是java分治思想之ForkJoin怎麼應用的詳細內容。更多資訊請關注PHP中文網其他相關文章！