详细分析JAVA 线程池

系统启动一个新线程的成本是比较高的,因为它涉及与操作系统交互。在这种情形下,使用线程池可以很好地提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池。

与数据库连接池类似的是,线程池在系统启动时即创建大量空闲的线程,程序将一个 Runnable 对象或 Callable 对象传给线程池,线程池就会启动一个线程来执行它们的 run() 或 call() 方法,当 run() 或 call() 方法执行结束后,该线程并不会死亡,而是再次返回线程池成为空闲状态,等待执行下一个 Runnable 对象的 run() 或 call() 方法。

除此之外,使用线程池可以有效地控制系统中并发线程的数量,当系统中包含大量并发线程时,会导致系统性能剧烈下降,甚至导致 JVM 崩溃,而线程池的最大线程数参数可以控制系统中并发线程数不超过此数。

Java 8 改进的线程池

在 Java 5 以前,开发者必须手动实现自己的线程池;从 Java 5 开始, Java 内建支持线程池。 Java 5 新增了一个 Executors 工厂类来产生线程池,该工厂类包含如下几个静态工厂方法来创建线程池。

  • newCachedThreadPool():创建一个具有缓存功能的线程池,系统根据需要创建线程,这些线程将会被缓存在线程池中。
  • newFixedThreadPool(int nThreads):创建一个可重用的、具有固定线程数的线程池。
  • newSingleThreadExecutor():创建一个只有单线程的线程池,它相当于调用 newFixedThreadPool() 方法时传入参数为1。
  • newScheduledThreadPool(int corePoolSize):创建具有指定线程数的线程池,它可以在指定延迟后执行线程任务。 corePoolSize 指池中所保存的线程数,即使线程是空闲的也被保存在线程池内。
  • newSingleThreadScheduledExecutor():创建只有一个线程的线程池,它可以在指定延迟后执行线程任务。
  • ExecutorService newWorkStealingPool(int parallelism):创建持有足够的线程的线程池来支持给定的并行级别,该方法还会使用多个队列来减少竞争。
  • ExecutorService newWorkStealingPool():该方法是前一个方法的简化版本。如果当前机器有 4 个CPU, 则目标并行级别被设置为 4,也就是相当于为前一个方法传入 4 作为参数。

上面7个方法中的前三个方法返回一个 ExecutorService 对象,该对象代表一个线程池,它可以执行 Runnable 对象或 Callable 对象所代表的线程;而中间两个方法返回一个 ScheduledExecutorService 线程池,它是 ExecutorService 的子类,它可以在指定延迟后执行线程任务;最后两个方法则是 Java 8 新增的,这两个方法可充分利用多 CPU 并行的能力。这两个方法生成的 work stealing 池,都相当于后台线程池,如果所有的前台线程都死亡了,work stealing 池中的线程会自动死亡。

由于目前计算机硬件的发展日新月异,即使普通用户使用的电脑通常也都是多核 CPU,因此 Java 8 在线程支持上也增加了利用多 CPU 并行的能力,这样可以更好地发挥底层硬件的性能。

ExecutorService 代表尽快执行线程的线程池(只要线程池中有空闲线程,就立即执行线程任务),程序只要将一个 Runnable 对象或 Callable 对象(代表线程任务)提交给该线程池,该线程池就会尽快执行该任务。 ExecutorService 里提供了如下三个方法。

  • Future <?>  submit(Runnable task):将一个 Runnable 对象提交给指定的线程池,线程池将在有空闲线程时执行 Runnable 对象代表的任务。其中 Future 对象代表 Runnable 任务的返回值,但 run() 方法没有返回值,所以 Future 对象将在 run() 方法执行结束后返回 null 。但可以调用 Future 的 isDone()、 isCancelled() 方法来获得 Runnable 对象的执行状态。
  • <T> Future <T>  submit(Runnable task,  T result):将一个 Runnable 对象提交给指定的线程池,线程池将在有空闲线程时执行 Runnable 对象代表的任务。其中 result 显式指定线程执行结束后的返回值,所以 Future 对象将在 run() 方法执行结束后返回 result 。
  • <T> Future <T>  submit(Callable <T>   task):将一个 Callable 对象提交给指定的线程池,线程池将在有空闲线程时执行 Callable 对象代表的任务。其中 Future 代表 Callable 对象里 call() 方法的返回值。

ScheduledExecutorService 代表可在指定延迟后或周期性地执行线程任务的线程池,它提供了如下4个方法。

  • ScheduledFuture<V>  schedule (Callable<V>  callable,  long delay, TimeUnit unit):指定 callable 任务将在 delay 延迟后执行。
  • ScheduledFuture<?>  schedule(Runnable command , long delay , TimeUnit unit):指定 command 任务将在 delay 延迟后执行。
  • ScheduledFuture<?>  scheduleAtFixedRate(Runnable command,  long initialDelay,  long period , TimeUnit unit) : 指定 command 任务将在 delay 延迟后执行,而且以设定频率重复执行。也就是说,在 initialDelay 后开始执行,依次在 initialDelay + period 、 initialDelay +2* period …处重复执行,依此类推。
  • ScheduledFuture<?>   scheduleWithFixedDelay(Runnable command,  long initialDelay,  long delay, TimeUnit unit):创建并执行一个在给定初始延迟后首次启用的定期操作,随后在每一次执行终止和下一次执行开始之间都存在给定的延迟。如果任务在任一次执行时遇到异常,就会取消后续执行;否则,只能通过程序来显式取消或终止该任务。

用完一个线程池后,应该调用该线程池的 shutdown() 方法,该方法将启动线程池的关闭序列,调用 shutdown() 方法后的线程池不再接收新任务,但会将以前所有已提交任务执行完成。当线程池中的所有任务都执行完成后,池中的所有线程都会死亡;另外也可以调用线程池的 shutdownNow() 方法来关闭线程池,该方法试图停止所有正在执行的活动任务,暂停处理正在等待的任务,并返回等待执行的任务列表。

使用线程池来执行线程任务的步骤如下。

  • 调用 Executors 类的静态工厂方法创建一个 ExecutorService 对象,该对象代表一个线程池。
  • 创建 Runnable 实现类或 Callable 实现类的实例,作为线程执行任务。
  • 调用 ExecutorService 对象的 submit() 方法来提交 Runnable 实例或 Callable 实例。
  • 当不想提交任何任务时,调用 ExecutorService 对象的 shutdown() 方法来关闭线程池。

下面程序使用线程池来执行指定 Runnable 对象所代表的任务。

//实现Runnable接口来定义一个简单的
class TestThread implements Runnable{
 public void run(){
  for (int i = 0; i < 100 ; i++ ){
   System.out.println(Thread.currentThread().getName()
    + "的i值为:" + i);
  }
 }
}

public class ThreadPoolTest{
 public static void main(String[] args) {
  //创建一个具有固定线程数(6)的线程池
  ExecutorService pool = Executors.newFixedThreadPool(6);
  //向线程池中提交2个线程
  pool.submit(new TestThread());
  pool.submit(new TestThread());
  //关闭线程池
  pool.shutdown();
 }
}

上面程序中创建 Runnable 实现类与最开始创建线程池并没有太大差别,创建了 Runnable 实现类之后程序没有直接创建线程、启动线程来执行该 Runnable 任务,而是通过线程池来执行该任务,使用线程池来执行 Runnable 任务的代码如程序中粗体字代码所示。运行上面程序,将看到两个线程交替执行的效果,如下图所示。

Java 8  增强的 ForkJoinPool

现在计算机大多已向多 CPU 方向发展,即使普通 PC ,甚至小型智能设备(如手机)、多核处理器也已被广泛应用。在未来的日子里,处理器的核心数将会发展到更多。

虽然硬件上的多核 CPU 已经十分成熟,但很多应用程序并未为这种多核 CPU 做好准备,因此并不能很好地利用多核 CPU 的性能优势。

为了充分利用多 CPU 、多核 CPU 的性能优势,计算机软件系统应该可以充分“挖掘”每个 CPU 的计算能力,绝不能让某个 CPU 处于“空闲”状态。为了充分利用多 CPU 、多核 CPU 的优势,可以考虑把一个任务拆分成多个“小任务”,把多个“小任务”放到多个处理器核心上并行执行;当多个“小任务”执行完成之后,再将这些执行结果合并起来即可。

Java 7 提供了 ForkJoinPool 来支持将一个任务拆分成多个“小任务”并行计算,再把多个“小任务”的结果合并成总的计算结果。 ForkJoinPool 是 ExecutorService 的实现类,因此是一种特殊的线程池。ForkJoinPool 提供了如下两个常用的构造器。

  • ForkJoinPool(int parallelism):创建一个包含 parallelism 个并行线程的 ForkJoinPool 。
  • ForkJoinPool():以 Runtime.availableProcessors() 方法的返回值作为 parallelism 参数来创建 ForkJoinPool

Java 8 进一步扩展了 ForkJoinPool 的功能 ,Java 8 为 ForkJoinPool 增加了通用池功能。 ForkJoinPool 类通过如下两个静态方法提供通用池功能。

  • ForkJoinPool commonPool():该方法返回一个通用池,通用池的运行状态不会受 shutdown() 或 shutdownNow() 方法的影响。当然,如果程序直接执行 System.exit(0); 来终止虚拟机,通用池以及通用池中正在执行的任务都会被自动终止。
  • int getCommonPoolParallelism():该方法返回通用池的并行级别。

创建了 ForkJoinPool 实例之后,就可调用 ForkJoinPool 的 submit(ForkJoinTask task) 或 invoke(ForkJoinTask task) 方法来执行指定任务了。其中 ForkJoinTask 代表一个可以并行、合并的任务。ForkJoinTask 是一个抽象类,它还有两个抽象子类 : RecursiveAction 和 RecursiveTask 。其中 RecursiveTask 代表有返回值的任务,而 RecursiveAction 代表没有返回值的任务。

下面以执行没有返回值的“大任务”(简单地打印0〜300的数值)为例,程序将一个“大任务”拆分成多个“小任务”,并将任务交给 ForkJoinPool 来执行。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeUnit;

class PrintTask extends RecursiveAction{
 // 每个“小任务”最多只打印50个数
 private static final int THRESHOLD = 50;
 private int start;
 private int end;

 // 打印从 start 到 end 的任务
 public PrintTask(int start, int end) {
  this.start = start;
  this.end = end;
 }

 @Override
 protected void compute() {
  // 当 end 与 start 之间的差小于 THRESHOLD 时,开始打印
  if(end-start<THRESHOLD) {
   for(int i=start;i<end;i++) {
    System.out.println(Thread.currentThread().getName()+"的 i 值:"+i);
   }
  }else {
   // 当 end 与 start 之间的差大于 THRESHOLD 时,即要打印的数超过50个时
   // 将大任务分解成两个“小任务”
   int middle = (start+end)/2;
   PrintTask left = new PrintTask(start, middle);
   PrintTask right = new PrintTask(middle, end);
   // 并行执行两个“小任务”
   left.fork();
   right.fork();
  }
 }
}

public class ForkJoinPoolTest {
 public static void main(String[] args) throws Exception {
  ForkJoinPool pool = new ForkJoinPool();
  // 提交可分解的 PrintTask 任务
  pool.submit(new PrintTask(0, 300));
  pool.awaitTermination(2, TimeUnit.SECONDS);
  // 关闭线程池
  pool.shutdown();
 }
}

上面程序中的粗体字代码实现了对指定打印任务的分解,分解后的任务分别调用 fork() 方法开始并行执行。运行上面程序,可以看到如下图所示的结果。

从如上图所示的执行结果来看, ForkJoinPool 启动了 4个线程来执行这个打印任务——这是因为测试计算机的 CPU 是4核的。不仅如此,读者可以看到程序虽然打印了 0〜299这300个数字,但并不是连续打印的,这是因为程序将这个打印任务进行了分解,分解后的任务会并行执行,所以不会按顺序从0打印到299。

上面定义的任务是一个没有返回值的打印任务,如果大任务是有返回值的任务,则可以让任务继承 RecursiveTask<T>,其中泛型参数 T 就代表了该任务的返回值类型。下面程序示范了使用 RecursiveTask 对一个长度为100的数组的元素值进行累加。

package com.jwen.demo4;

import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
import java.util.function.Function;

class CalTask extends RecursiveTask<Integer>{

 // 每个“小任务”最多只累加20个数
 private static final int THRESHOLD = 20;
 private int arr[];
 private int start;
 private int end;
 // 累加从 start 到 end 的数组元素
 public CalTask(int[] arr, int start, int end) {
  this.arr = arr;
  this.start = start;
  this.end = end;
 }

 @Override
 protected Integer compute() {
  int sum = 0;
  // 当 end 与 start 之间的差小于 THRESHOLD 时,开始进行实际累加
  if(end-start<THRESHOLD) {
   for(int i=start;i<end;i++) {
    sum+=arr[i];
   }
   return sum;
  }else {
   // 当 end 与 start 之间的差大于 THRESHOLD 时,即要累加的数超过20个时
   // 将大任务分解成两个“小任务”
   int middle = (start+end)/2;
   CalTask left = new CalTask(arr, start, middle);
   CalTask right = new CalTask(arr, middle, end);
   // 并行执行两个“小任务”
   left.fork();
   right.fork();
   // 把两个“小任务”累加的结果合并起来
   return left.join()+right.join(); // ①
  }
 }
}

public class Sum {
 public static void main(String[] args) throws Exception{
  int[] arr = new int[100];
  Random rand = new Random();
  int total = 0;
  // 初始化100个数字元素
  for(int i=0,len = arr.length;i<len;i++) {
   int tmp = rand.nextInt(20);
   // 对数组元素赋值,并将数组元素的值添加到 sum 总和中
   total +=(arr[i]=tmp);
  }
  System.out.println(total);
  // 创建一个通用池
  ForkJoinPool pool = ForkJoinPool.commonPool();
  // 提交可分解的 CalTask 任务
  Future<Integer> future = pool.submit(new CalTask(arr, 0, arr.length));
  System.out.println(future.get());
  // 关闭线程池
  pool.shutdown();
 }
}

上面程序与前一个程序基本相似,同样是将任务进行了分解,并调用分解后的任务的 fork() 方法使它们并行执行。与前一个程序不同的是,现在任务是带返回值的,因此程序还在①号代码处将两个分解后的“小任务”的返回值进行了合并。

运行上面程序,将可以看到程序通过 CalTask 计算出来的总和,与初始化数组元素时统计出来的总和总是相等,这表明程序一切正常。

Java 的确是一门非常优秀的编程语言,在多 CPU、多核 CPU 时代来到时,Java 语言的多线程已经为多核 CPU 做好了准备。

以上就是详细分析JAVA 线程池的详细内容,更多关于JAVA 线程池的资料请关注我们其它相关文章!

(0)

相关推荐

  • JAVA线程池专题(概念和作用)

    线程池的作用 我们在用一个东西的时候,首先得搞明白一个问题.这玩意是干嘛的,为啥要用这个,用别的不行吗.那么一个一个解决这些问题 我们之前都用过数据库连接池,线程池的作用和连接池有点类似,频繁的创建,销毁线程会造成大量的不必要的性能开销,所以这个时候就出现了一个东西统一的管理线程,去负责线程啥时候销毁,啥时候创建,以及维持线程的状态,当程序需要使用线程的时候,直接从线程池拿,当程序用完了之后,直接把线程放回线程池,不需要去管线程的生命周期,专心的执行业务代码就行. 当然,如果非要是自己想手动ne

  • Java 线程状态和等待唤醒机制和线程池的实现

    1.概念 线程一共有6中状态,相互之间可以互相转换. 等待唤醒案例(线程之间的通信) 实现: 等待唤醒案例:线程之间的通信 创建一个顾客线程(消费者):告知老板要的包子的种类和数量,调用wait方法,放弃cpu的执行,进入到WAITING状态(无限等待) 创建一个老板线程(生产者):花了5秒做包子,做好包子之后,调用notify方法,唤醒顾客吃包子 注意: 顾客和老板线程必须使用同步代码块包裹起来,保证等待和唤醒只能有一个在执行 同步使用的锁对象必须保证唯一 只有锁对象才能调用wait和noti

  • java 定时器线程池(ScheduledThreadPoolExecutor)的实现

    前言 定时器线程池提供了定时执行任务的能力,即可以延迟执行,可以周期性执行.但定时器线程池也还是线程池,最底层实现还是ThreadPoolExecutor,可以参考我的另外一篇文章多线程–精通ThreadPoolExecutor. 特点说明 1.构造函数 public ScheduledThreadPoolExecutor(int corePoolSize) { // 对于其他几个参数在ThreadPoolExecutor中都已经详细分析过了,所以这里,将不再展开 // 这里我们可以看到调用基类

  • Java判断线程池线程是否执行完毕

    在使用多线程的时候有时候我们会使用 java.util.concurrent.Executors的线程池,当多个线程异步执行的时候,我们往往不好判断是否线程池中所有的子线程都已经执行完毕,但有时候这种判断却很有用,例如我有个方法的功能是往一个文件异步地写入内容,我需要在所有的子线程写入完毕后在文件末尾写"---END---"及关闭文件流等,这个时候我就需要某个标志位可以告诉我是否线程池中所有的子线程都已经执行完毕,我使用这种方式来判断. public class MySemaphore

  • Java手动配置线程池过程详解

    线程池中,常见有涉及到的: ExecutorService executorService = Executors.newSingleThreadExecutor(); ExecutorService executorService1 = Executors.newCachedThreadPool(); ExecutorService executorService2 = Executors.newFixedThreadPool(3); 关于Executors和ExecutorService从记

  • java 线程池的实现方法

    线程池有以下几种实现方式: Executors目前提供了5种不同的线程池创建配置: 1.newCachedThreadPool() 它是用来处理大量短时间工作任务的线程池,具有几个鲜明特点:它会试图缓存线程并重用,当无缓存线程可用时,就会创建新的工作线程:如果线程闲置时间超过60秒,则被终止并移除缓存:长时间闲置时,这种线程池,不会消耗什么资源.其内部使用SynchronousQueue作为工作队列. 2.newFixedThreadPool(int nThreads) 重用指定数目(nThre

  • Java线程池ThreadPoolExecutor原理及使用实例

    引导 要求:线程资源必须通过线程池提供,不允许在应用自行显式创建线程: 说明:使用线程池的好处是减少在创建和销毁线程上所花的时间以及系统资源的开销,解决资源不足的问题.如果不使用线程池,有可能造成系统创建大量同类线程而导致消耗内存或者"过度切换"的问题. 线程池介绍线程池概述   线程池,顾名思义是一个放着线程的池子,这个池子的线程主要是用来执行任务的.当用户提交任务时,线程池会创建线程去执行任务,若任务超过了核心线程数的时候,会在一个任务队列里进行排队等待,这个详细流程,我们会后面细

  • Java线程池ForkJoinPool实例解析

    这篇文章主要介绍了Java线程池ForkJoinPool实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 背景:ForkJoinPool的优势在于,可以充分利用多cpu,多核cpu的优势,把一个任务拆分成多个"小任务",把多个"小任务"放到多个处理器核心上并行执行:当多个"小任务"执行完成之后,再将这些执行结果合并起来即可.这种思想值得学习. import java.io.IOExcept

  • 详细分析JAVA 线程池

    系统启动一个新线程的成本是比较高的,因为它涉及与操作系统交互.在这种情形下,使用线程池可以很好地提高性能,尤其是当程序中需要创建大量生存期很短暂的线程时,更应该考虑使用线程池. 与数据库连接池类似的是,线程池在系统启动时即创建大量空闲的线程,程序将一个 Runnable 对象或 Callable 对象传给线程池,线程池就会启动一个线程来执行它们的 run() 或 call() 方法,当 run() 或 call() 方法执行结束后,该线程并不会死亡,而是再次返回线程池成为空闲状态,等待执行下一个

  • 超详细讲解Java线程池

    目录 池化技术 池化思想介绍 池化技术的应用 如何设计一个线程池 Java线程池解析 ThreadPoolExecutor使用介绍 内置线程池使用 ThreadPoolExecutor解析 整体设计 线程池生命周期 任务管理解析 woker对象 Java线程池实践建议 不建议使用Exectuors 线程池大小设置 线程池监控 带着问题阅读 1.什么是池化,池化能带来什么好处 2.如何设计一个资源池 3.Java的线程池如何使用,Java提供了哪些内置线程池 4.线程池使用有哪些注意事项 池化技术

  • 详细分析java线程wait和notify

    wait()和notify()是直接隶属于Object类,也就是说,所有对象都拥有这一对方法.初看起来这十分 不可思议,但是实际上却是很自然的,因为这一对方法阻塞时要释放占用的锁,而锁是任何对象都具有的,调用任意对象的 wait() 方法导致线程阻塞,并且该对象上的锁被释放.而调用任意对象的notify()方法则导致因调用该对象的wait() 方法而阻塞的线程中随机选择的一个解除阻塞(但要等到获得锁后才真正可执行). 其次,wait()和notify()可在任何位置调用,但是这一对方法却必须在

  • java线程池核心API源码详细分析

    目录 概述 源码分析 Executor ExecutorService ScheduledExecutorService ThreadPoolExecutor ScheduledThreadPoolExecutor 总结 概述 线程池是一种多线程处理形式,处理过程中将任务添加到队列,然后在创建线程后自动启动这些任务.线程池线程都是后台线程.每个线程都使用默认的堆栈大小,以默认的优先级运行,并处于多线程单元中.如果某个线程在托管代码中空闲(如正在等待某个事件),则线程池将插入另一个辅助线程来使所有

  • 非常适合新手学生的Java线程池超详细分析

    目录 线程池的好处 创建线程池的五种方式 缓存线程池CachedThreadPool 固定容量线程池FixedThreadPool 单个线程池SingleThreadExecutor 定时任务线程池ScheduledThreadPool ThreadPoolExecutor创建线程池(十分推荐) ThreadPoolExecutor的七个参数详解 workQueue handler 如何触发拒绝策略和线程池扩容? 线程池的好处 可以实现线程的复用,避免重新创建线程和销毁线程.创建线程和销毁线程对

  • java线程池的四种创建方式详细分析

    目录 前言 1. 线程池 2. 创建方式 前言 在讲述线程池的前提 先补充一下连接池的定义 连接池是创建和管理一个连接的缓冲池的技术,这些连接准备好被任何需要它们的线程使用 可以看到其连接池的作用如下: 1. 线程池 线程池(英语:thread pool):一种线程使用模式.线程过多会带来调度开销,进而影响缓存局部性和整体性能.而线程池维护着多个线程,等待着监督管理者分配可并发执行的任务.这避免了在处理短时间任务时创建与销毁线程的代价.线程池不仅能够保证内核的充分利用,还能防止过分调度 特点:

  • 详解Java线程池和Executor原理的分析

    详解Java线程池和Executor原理的分析 线程池作用与基本知识 在开始之前,我们先来讨论下"线程池"这个概念."线程池",顾名思义就是一个线程缓存.它是一个或者多个线程的集合,用户可以把需要执行的任务简单地扔给线程池,而不用过多的纠结与执行的细节.那么线程池有哪些作用?或者说与直接用Thread相比,有什么优势?我简单总结了以下几点: 减小线程创建和销毁带来的消耗 对于Java Thread的实现,我在前面的一篇blog中进行了分析.Java Thread与内

  • Java线程池7个参数的详细含义

    目录 一.corePoolSize线程池核心线程大小 二.maximumPoolSize线程池最大线程数量 三.keepAliveTime空闲线程存活时间 四.unit空闲线程存活时间单位 五.workQueue工作队列 六.threadFactory线程工厂 七.handler拒绝策略 java多线程开发时,常常用到线程池技术,这篇文章是对创建java线程池时的七个参数的详细解释. 从源码中可以看出,线程池的构造函数有7个参数 这 7 个参数分别是: corePoolSize:核心线程数. m

  • Java线程池用法实战案例分析

    本文实例讲述了Java线程池用法.分享给大家供大家参考,具体如下: 一 使用newSingleThreadExecutor创建一个只包含一个线程的线程池 1 代码 import java.util.concurrent.*; public class executorDemo { public static void main( String[] args ) { ExecutorService executor = Executors.newSingleThreadExecutor(); ex

  • Java线程池的应用实例分析

    本文实例讲述了Java线程池的应用.分享给大家供大家参考,具体如下: 一 使用Future与Callable来计算斐波那契数列 1 代码 import java.util.concurrent.*; public class FutureCallableDemo { static long fibonacci(long n) { if (n == 1 ||n == 2) return 1; else return fibonacci(n - 1) + fibonacci(n - 2); } pu

随机推荐