Java Fork / Join Framework示例

缺乏、安全感 2023-02-15 05:14 17阅读 0赞

> **什么是Fork / Join？**  
> 阅读[Doug Lea撰写的Java Fork / Join论文][Doug Lea_Java Fork _ Join]

自Java 7起，便提供了fork / join框架，从而使编写并行程序变得更加容易。 我们可以通过扩展`RecursiveTask`或`RecursiveAction`来实现fork / join框架。

## 1.分叉/加入– RecursiveTask ##

一个fork联接示例，对一个范围内的所有数字求和。

ForkJoinAdd.java

package com.mkyong.concurrency.forkjoin;
    
    import java.util.concurrent.ForkJoinPool;
    import java.util.concurrent.ForkJoinTask;
    import java.util.concurrent.RecursiveTask;
    import java.util.stream.LongStream;
    
    public class ForkJoinAdd extends RecursiveTask<Long> {
    
        private final long[] numbers;
        private final int start;
        private final int end;
        public static final long threshold = 10_000;
    
        public ForkJoinAdd(long[] numbers) {
            this(numbers, 0, numbers.length);
        }
    
        private ForkJoinAdd(long[] numbers, int start, int end) {
            this.numbers = numbers;
            this.start = start;
            this.end = end;
        }
    
        @Override
        protected Long compute() {
    
            int length = end - start;
            if (length <= threshold) {
                return add();
            }
    
            ForkJoinAdd firstTask = new ForkJoinAdd(numbers, start, start + length / 2);
            firstTask.fork(); //start asynchronously
    
            ForkJoinAdd secondTask = new ForkJoinAdd(numbers, start + length / 2, end);
    
            Long secondTaskResult = secondTask.compute();
            Long firstTaskResult = firstTask.join();
    
            return firstTaskResult + secondTaskResult;
    
        }
    
        private long add() {
            long result = 0;
            for (int i = start; i < end; i++) {
                result += numbers[i];
            }
            return result;
        }
    
        public static long startForkJoinSum(long n) {
            long[] numbers = LongStream.rangeClosed(1, n).toArray();
            ForkJoinTask<Long> task = new ForkJoinAdd(numbers);
            return new ForkJoinPool().invoke(task);
        }
    
    }

运行。 将所有数字相加（从1到1百万）。

Main.java

package com.mkyong.concurrency.forkjoin;
    
    public class Main {
    
        public static void main(String[] args) {
    
            System.out.println(ForkJoinAdd.startForkJoinSum(1_000_000));
    		
        }
    
    }

输出量

500000500000

## 2. Fork / Join –递归动作 ##

一个叉连接示例，通过使用递归循环来查找斐波那契数。

> **注意**  
> 此方法仅用于Fork / Join演示，递归循环很慢。 试试这个[Java Fibonacci示例，][Java Fibonacci]以更快地找到斐波那契数。

ForkJoinFibonacci.java

package com.mkyong.concurrency.forkjoin;
    
    import java.util.concurrent.ForkJoinTask;
    import java.util.concurrent.RecursiveAction;
    
    public class ForkJoinFibonacci extends RecursiveAction {
    
        private static final long threshold = 10;
        private volatile long number;
    
        public ForkJoinFibonacci(long number) {
            this.number = number;
        }
    
        public long getNumber() {
            return number;
        }
    
        @Override
        protected void compute() {
            long n = number;
            if (n <= threshold) {
                number = fib(n);
            } else {
                ForkJoinFibonacci f1 = new ForkJoinFibonacci(n - 1);
                ForkJoinFibonacci f2 = new ForkJoinFibonacci(n - 2);
                ForkJoinTask.invokeAll(f1, f2);
                number = f1.number + f2.number;
            }
        }
    
        private static long fib(long n) {
            if (n <= 1) return n;
            else return fib(n - 1) + fib(n - 2);
        }
    
    }

运行它，找到第50个斐波那契数。

Main.java

package com.mkyong.concurrency.forkjoin;
    
    import java.util.concurrent.ForkJoinPool;
    
    public class Main {
    
        public static void main(String[] args) {
    
            ForkJoinFibonacci task = new ForkJoinFibonacci(50);
            new ForkJoinPool().invoke(task);
    
            System.out.println(task.getNumber());
    
        }
    
    }

输出量

12586269025

> **RecursiveTask和RecursiveAction之间的区别？**  
> 两者是相同的，只是`RecursiveTask`返回一个值，而RecursiveAction不返回任何值，无效。

## 下载源代码 ##

> $ git clone [https://github.com/mkyong/java-concurrency.git][https_github.com_mkyong_java-concurrency.git]

## 参考文献 ##

1.  [甲骨文– Fork / Join][Fork _ Join]
2.  [Java Fork-Join灾难][Java Fork-Join]
3.  [Doug Lea – Java Fork / Join框架][Doug Lea_Java Fork _ Join]
4.  [维基百科-斐波那契数][-]
5.  [Java Fibonacci示例][Java Fibonacci]
6.  [RecursiveTask JavaDoc][]
7.  [RecursiveAction JavaDoc][]

标签： [并发][Link 1] [斐波那契][Link 2] [叉加入][Link 3] [Java 7][]

> 翻译自: [https://mkyong.com/java/java-fork-join-framework-examples/][https_mkyong.com_java_java-fork-join-framework-examples]

[Doug Lea_Java Fork _ Join]: http://gee.cs.oswego.edu/dl/papers/fj.pdf
[Java Fibonacci]: https://www.mkyong.com/java/java-fibonacci-examples/
[https_github.com_mkyong_java-concurrency.git]: https://github.com/mkyong/java-concurrency.git
[Fork _ Join]: https://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html
[Java Fork-Join]: http://coopsoft.com/ar/CalamityArticle.html
[-]: https://en.wikipedia.org/wiki/Fibonacci_number
[RecursiveTask JavaDoc]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveTask.html
[RecursiveAction JavaDoc]: https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveAction.html
[Link 1]: https://mkyong.com/tag/concurrency/
[Link 2]: https://mkyong.com/tag/fibonacci/
[Link 3]: https://mkyong.com/tag/fork-join/
[Java 7]: https://mkyong.com/tag/java-7/
[https_mkyong.com_java_java-fork-join-framework-examples]: https://mkyong.com/java/java-fork-join-framework-examples/