平行斐波那契数计算器

Question

我正在使用任务并行库 (TPL) 来计算斐波那契数。 程序如下：

        public static int Fib(int n)
        {
            if (n <= 1)
            {
                return n;
            }
            Task<int> task = Task.Factory.StartNew<int>(() => Fib(n - 1));
            var p = Fib(n - 2);
            return task.Result + p;
        }

        public static void Main(string[] args)
        {

            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("Answer: " + Fib(44));
            watch.Stop();
            Console.WriteLine("Time: " + watch.ElapsedMilliseconds);
        }
    }

很遗憾，这个程序需要很长时间才能完成。 但是这个程序的串行版本（如下所示）需要不到 30 秒 计算第 44 个斐波那契数。

 public class FibTester
    {
        public static int Fib(int n)
        {
            if (n <= 1)
            {
                return n;
            }
            var q = Fib(n - 1);
            var p = Fib(n - 2);
            return p + q;
        }

        public static void Main(string[] args)
        {

            Stopwatch watch = new Stopwatch();
            watch.Start();
            Console.WriteLine("Answer: " + Fib(44));
            watch.Stop();
            Console.WriteLine("Time: " + watch.ElapsedMilliseconds);
        }
    }

我认为并行版本的问题是，它为每个 Fib(n - 1) 创建一个线程 要求。有什么方法可以控制在 TPL 中创建的线程数？

Answer 1

这是不多线程的完美示例！

您正在为递归函数的每次迭代创建一个新任务。因此，每个任务都会创建一个新任务，等待该任务完成，然后将结果中的数字相加。

每个线程有两个工作：1 - 创建一个新线程，2 - 添加两个数字。

创建每个线程的开销成本将远远超过将两个数字相加的成本。

---

为了回答您关于限制创建的线程数量的问题，TPL 使用了 ThreadPool。您可以使用ThreadPool.SetMaxThreads 限制线程数。

Answer 2

我认为很明显斐波那契不能并行化，除非你提前知道一些相邻的斐波那契数对

只需要迭代代码。

无论您做什么，都不要在每次迭代/递归时生成任务/线程！开销会扼杀性能。即使应用了并行化，这也是一个很大的反模式。

Answer 3

只是为了好玩:)

using System;
using System.Linq;
using System.Threading.Tasks;

public class Program
{
    static readonly double sqrt5 = Math.Sqrt(5);
    static readonly double p1 = (1 + sqrt5) / 2;
    static readonly double p2 = -1 * (p1 - 1);

    static ulong Fib1(int n) // surprisingly slightly slower than Fib2
    {
        double n1 = Math.Pow(p1, n+1);
        double n2 = Math.Pow(p2, n+1);
        return (ulong)((n1-n2)/sqrt5);
    }

    static ulong Fib2(int n) // 40x faster than Fib3
    {
        double n1 = 1.0;
        double n2 = 1.0;
        for (int i=0; i<n+1; i++)
        {
            n1*=p1;
            n2*=p2;
        }
        return (ulong)((n1-n2)/sqrt5);
    }

    static ulong Fib3(int n) // that's fast! Done in 1.32s
    {
        double n1 = 1.0;
        double n2 = 1.0;
        Parallel.For(0,n+1,(x)=> {
            n1 *= p1; 
            n2 *= p2; 
        });
        return (ulong)((n1-n2)/sqrt5);
    }

    public static void Main(string[] args)
    {
        for (int j=0; j<100000; j++)
            for (int i=0; i<90; i++)
                Fib1(i);
        for (int i=0; i<90; i++)
            Console.WriteLine(Fib1(i));
    }
}

Answer 4

您的程序非常无能，因为重复了相同的计算（Fib(n-1) 实际上重新计算了所有数字

你应该试试这个：

class Program
{
    static void Main(string[] args)
    {
        var sw = new Stopwatch();
        sw.Start();
        foreach (var nbr in Fibo().Take(5000))
        {
            Console.Write(nbr.ToString() + " ");
        }
        sw.Stop();
        Console.WriteLine();
        Console.WriteLine("Ellapsed : " + sw.Elapsed.ToString());
        Console.ReadLine();
    }

    static IEnumerable<long> Fibo()
    {
        long a = 0;
        long b = 1;
        long t;

        while (true)
        {
            t = a + b;
            yield return t;
            a = b;
            b = t;
        }
    }
}

在 5 毫秒内找到第 44 个。

代码中最慢的部分是循环中的 Console.Write。