【问题标题】:Using threads and recursion in Java to calculate Fibonacci numbers在 Java 中使用线程和递归计算斐波那契数
【发布时间】:2009-04-01 15:25:52
【问题描述】:

我是 Java 领域的新手,但我有一个不明白的问题。

我有一个类(获取斐波那契行):

class Fib {
    public static int f(int x){
        if ( x < 2 )
            return 1;       
        else 
            return f(x-1)+ f(x-2);      
    }
}

现在的任务是在单独的线程中启动 f(x-1) 和 f(x-2)。 一次是实现 Thread 类,另一次是实现 Runnable。 你可能知道,这是我教授的练习。

我知道如何在 Java 中启动一个线程,并且我知道整个线程在理论上是如何工作的,但是我找不到在这个递归函数中启动单独线程的解决方案。

在run函数中要做什么?

大概

public void run(){
//int foo=start f(this.x-1)
    //int bar=start f(this.x-2)  
    //return foo+bar?
}

如何将 x 粘贴到我的可运行函数中? x 是否在创建时传递给对象?

Class Fib ...{
  int x;
  public ... run ... 
  public ... f(x)....

}

在主方法中

(new Fib(x)).start();

还是我走错了路?

【问题讨论】:

    标签: java multithreading recursion


    【解决方案1】:

    为此,您需要 1) 将数字传递给新线程的方法,2) 启动线程,3) 等待线程完成,以及 4) 获取结果的方法来自线程。

    你可以通过构造函数传入数字。您可以有一个名为“answer”的公共数据成员来包含计算结果。可以使用start()方法启动线程,join()方法等待线程完成。

    以下示例演示了这一点。这应该是一个很好的起点;您可以从这里抽象出一些杂乱无章的东西,以便根据需要获得更好的 API。

    public class Fib extends Thread
    {
        private int x;
        public int answer;
    
        public Fib(int x) {
            this.x = x;
        }
    
        public void run() {
            if( x <= 2 )
                answer = 1;
            else {
                try {
                    Fib f1 = new Fib(x-1);
                    Fib f2 = new Fib(x-2);
                    f1.start();
                    f2.start();
                    f1.join();
                    f2.join();
                    answer = f1.answer + f2.answer;
                }
                catch(InterruptedException ex) { }
            }
        }
    
        public static void main(String[] args)
            throws Exception
        {
            try {
                Fib f = new Fib( Integer.parseInt(args[0]) );
                f.start();
                f.join();
                System.out.println(f.answer);
            }
            catch(Exception e) {
                System.out.println("usage: java Fib NUMBER");
            }
        }
    }
    

    【讨论】:

    • 非常感谢,这对我了解它们如何协同工作很有帮助
    • 哇,效率低得惊人。随着 n 的增加,创建的线程数呈指数增长。我从来没有想过这样做。但是,在停止进程之前,您可能会挂起机器。
    • 理想情况下,您将使用固定大小的线程池或其他东西,但这些概念可能只会使答案复杂化。这可能是解决 OP 问题的最简单的方法,所以 +1。
    • 我同意您永远不会真正想要以这种方式实现某些东西;这只是完成问题所要求的方法的最简单的工作测试程序。线程并不是解决这类问题的好方法,但这仍然是一个不错的教学问题。
    • 正如我在下面的评论中所写,这是我练习的确切答案。任务是了解线程和 Java 是如何工作的。另一个任务是做一个程序算法,它更高效,所以我们被教导线程并不总是最好的方法:)
    【解决方案2】:

    使用线程通常是为了提高性能。但是,每个线程都会增加开销,如果执行的任务很小,那么开销可能会比实际完成的工作多得多。此外,大多数 PC 只能处理大约 1000 个线程,如果线程数超过 10K,就会挂起。

    在您的情况下,fib(20) 将生成 6765 个线程,fib(30) 创建 832K,fib(40) 创建 102M 线程,fib(50) 创建超过 12 万亿个线程。我希望你能看到这是不可扩展的。

    但是,使用不同的方法,您可以在一分钟内计算出 fib(1000000)。

    import java.math.BigInteger;
    
    /*
    250000th fib # is: 36356117010939561826426 .... 10243516470957309231046875
    Time to compute: 3.466557 seconds.
    1000000th fib # is: 1953282128707757731632 .... 93411568996526838242546875
    Time to compute: 58.1 seconds.
    */
    public class Main {
        public static void main(String... args) {
            int place = args.length > 0 ? Integer.parseInt(args[0]) : 250 * 1000;
            long start = System.nanoTime();
            BigInteger fibNumber = fib(place);
            long time = System.nanoTime() - start;
    
            System.out.println(place + "th fib # is: " + fibNumber);
            System.out.printf("Time to compute: %5.1f seconds.%n", time / 1.0e9);
        }
    
        private static BigInteger fib(int place) {
            BigInteger a = new BigInteger("0");
            BigInteger b = new BigInteger("1");
            while (place-- > 1) {
                BigInteger t = b;
                b = a.add(b);
                a = t;
            }
            return b;
        }
    }
    

    【讨论】:

    • 显然,使用线程是任务的一部分。也许输入受到极大限制或其他什么。
    • 嗯,谢谢你解决了我作业的另一部分 :) 我的讲座被称为分布式编程,重点是线程、并行性。该任务太实现可运行,使用 Thread 类并在线程之间共享和存储数据的过程算法。
    • 从这个练习中你可以“了解到”线程很慢,最好不要使用它们。我不确定这是正确的结论。使用线程实际有帮助的作业会更好。
    • @PeterLawrey:我正在阅读您上面的代码,它非常简单,您能说出为什么使用BigInteger 类型比使用long 类型或其他类型更快......跨度>
    • @user1988876 long 只给你前 70 个斐波那契数,所以虽然使用 long 更快,但它不会运行很长时间(事实上你可以缓存前 70 个值)
    【解决方案3】:

    关于在fib 函数中启动线程以及通过构造函数将x 传递给对象,您已经有了正确的想法;您还需要有一种方法可以在最后从对象中获取计算结果 - 我相信您可以弄清楚 ;-) 您在 fib 中使用的线程启动过程只是同样的方式你总是启动一个线程,比如(new Fib(x-1)).start(),尽管你可能希望将线程保存在一个变量中,因为你以后需要它来获得计算结果。

    【讨论】:

    • 也谢谢你,我认为上面的帖子向我展示了如何更好地处理线程。
    【解决方案4】:

    所以在你们所有人的帮助下,我设法通过实现可运行而不是使用线程类来做同样的事情。

    如果任务是实现runnable,你们能不能看看并告诉我这是否是如何做到的。 代码本身有效。

    public class Fib implements Runnable
    {
    private int x;
    public  int answer;
    
    public Fib(int x) {
        this.x = x;
    }
    
    public void run() {
        if( x < 2 )
            answer = 1;
        else {
            try {
                Fib f1= new Fib(x-1);
                Fib f2= new Fib(x-2);
                Thread threadf1=new Thread(f1);
                Thread threadf2=new Thread(f2);
                threadf1.start();
                threadf2.start();
                threadf1.join();
                threadf2.join();
    
                answer = f1.answer + f2.answer;
    
            }
            catch(InterruptedException ex) { }
        }
    }
    
    public static void main(String[] args)
    
    {
        try {
    
                for (int i=0;i<19;i++){
                    Fib f= new Fib(i);
                    Thread threadf= new Thread(f);
                    threadf.start();
                    threadf.join();
    
                    System.out.println("Ergebnis:"+f.answer);
    
                }
            }
    
        catch(Exception e) {
            System.out.println("usage: java Fib NUMBER");
        }
      }
    }
    

    【讨论】:

      猜你喜欢
      • 1970-01-01
      • 1970-01-01
      • 2020-02-09
      • 2012-02-16
      • 2020-07-15
      • 1970-01-01
      • 1970-01-01
      • 1970-01-01
      • 2014-12-26
      相关资源
      最近更新 更多