RecursiveAction 如何与斐波那契一起工作？

Question

How does recursion work in case of Fibonacci. The below example uses RecursiveAction which does not return any value. But still it is possible to calculate Fibonacci numbers. I mean for example in case of Fibonacci(15). The threshold in below example is 10. So Fibonacci(15) cannot be calculated directly. So 2 other tasks will be created. ForkJoinFibonacci(n - 1) and ForkJoinFibonacci(n - 2). So in the below example only the member variable "number" stores the calculated Fibonacci number. But it is never returned. Only stored locally in each ForkJoinFibonacci class.So how can all the calculated numbers be summed up?

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);
        }
    }

To make it clear. It works. But I just do not know why it works.

Answer 1

The summing is in the compute method.

Each recursive action stores its own calculation in number. the compute method either finishes the calculation if it's small enough, storing it in the number field, or farms the work out to two more recursive actions, in which case it gets their results from their number field, sums them, and stores them in its own number field. the topmost recursive action exposes number through a getter.

An alternative way to write this is to replace the invokeAll with

f1.fork();
f2.compute();
f1.join();

That way the current thread is busy computing instead of bringing in another thread and waiting for it to do its work.