Java并发编程中的Fork/Join框架实战案例

原创深碍√TFBOYSˉ_ 2024-11-15 07:15 2阅读 0赞

Fork/Join框架是Java 1.5引入的一个并行计算模型，主要用于解决大规模数据的分治问题。

以下是一个简单的Fork/Join框架实战案例，假设我们有一个排序任务，需要对一个大型数组进行从小到大的排序：

```java
import java.util.ArrayList;
import java.util.List;

public class ForkJoinExample {
    public static void main(String[] args) {
        // 假设我们要排序的数组很大
        int[] array = generateLargeArray();

// 创建ForkJoinPool，它管理所有的worker thread
        List<Runnable> tasks = new ArrayList<>();
        tasks.add(new SortTask(array, 0, array.length - 1)));
        ForkJoinPool pool = new ForkJoinPool(tasks.size());

// 提交任务到工作线程池，它们会被自动分配给可用的worker thread
        long start = System.nanoTime();
        pool.invokeAll(tasks);
        long end = System.nanoTime();

// 打印排序结果和执行时间
        System.out.println("Sorted array: " + Arrays.toString(array)));
        System.out.println("Execution time: " + (end - start) / 1e6 + " seconds");
    }

static int[] generateLargeArray() {
        return new int[100000]; // 假设数组大小为100000
    }

static class SortTask implements Runnable {
        private final int[] array;
        private final int start;
        private final int end;

SortTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

@Override
        public void run() {
            mergeSort(array, start, end);
        }

private static void mergeSort(int[] array, int start, int end) {
            // Base case: if the subarray has only one element, it's already sorted
            if (start < end && array[start] > array[end]) {
                // swap elements
                int temp = array[start];
                array[start] = array[end];
                array[end] = temp;
            }

// Divide the array into two parts and recursively sort them
            if (start < end) {
                int mid = start + ((end - start) / 2));
                mergeSort(array, start, mid);
                mergeSort(array, mid + 1, end);
            }
        }
    }
}
```

这个例子中，我们首先创建一个大型数组，并将其作为待排序的任务。然后，我们将任务提交给ForkJoinPool的worker thread进行并行处理。

运行结果会打印出排序后的数组以及执行时间。