本文共 2518 字，大约阅读时间需要 8 分钟。

利用Future与Callable高效计算斐波那契数列

斐波那契数列是计算机科学中的经典问题之一，常用于测试并发计算框架的性能。本文将介绍如何利用Java的Future和Callable结合起来，实现高效计算斐波那契数列。

代码实现

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); 
        } 
    } 
    public static void main(String[] args) throws Exception { 
        Callable
   
     task = () -> fibonacci(30); 
        ExecutorService executor = Executors.newFixedThreadPool(1); 
        Future
    
      future = executor.submit(task); 
        System.out.println("计算第10个斐波那契数列，过会来取..."); 
        while (!future.isDone()) { 
            System.out.println("忙别的去吧，结果还在计算中..."); 
        } 
        System.out.printf("计算完毕，第10个斐波那契数列是:%d%n", future.get()); 
    } 
}
    
   

运行结果

计算第10个斐波那契数列，过会来取...
忙别的去吧，结果还在计算中...
...
忙别的去吧，结果还在计算中...
计算完毕，第10个斐波那契数列是:832040

通过上述代码，我们可以看到Future和Callable的结合使用，能够有效地并发执行斐波那契数列的计算。尽管使用了单线程的ExecutorService，但由于斐波那契数列的递归特性，实际上仍然需要等待所有递归调用完成。这表明在某些情况下，并发并不能显著提高性能。

线程池模拟多个工人并发处理任务

线程池是Java中处理并发任务的重要工具之一。通过线程池，我们可以轻松地创建多个执行者（worker），并让它们同时处理多个任务。下面，我们将通过一个简单的示例，展示如何使用ThreadPoolExecutor来模拟多个工人并发做工。

代码实现

import java.util.concurrent.*; 
import java.util.concurrent.TimeUnit; 
class Task implements Runnable { 
    private String name; 
    public Task(String name) { 
        this.name = name; 
    } 
    public String getName() { 
        return name; 
    } 
    @Override 
    public void run() { 
        try { 
            Long duration = (long)(Math.random() * 100); 
            System.out.println("正在做工中，执行者 : " + name); 
            TimeUnit.SECONDS.sleep(duration); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
    } 
}
public class BasicThreadPoolExecutorExample { 
    public static void main(String[] args) { 
        ThreadPoolExecutor executor = (ThreadPoolExecutor) Executors.newCachedThreadPool(); 
        for (int i = 0; i <= 5; i++) { 
            Task task = new Task("Task " + i); 
            System.out.println("新任务添加成功 : " + task.getName()); 
            executor.execute(task); 
        } 
        executor.shutdown(); 
    } 
}

运行结果

新任务添加成功 : Task 0
新任务添加成功 : Task 1
新任务添加成功 : Task 2
新任务添加成功 : Task 3
新任务添加成功 : Task 4
新任务添加成功 : Task 5
正在做工中，执行者 : Task 0
正在做工中，执行者 : Task 3
正在做工中，执行者 : Task 1
正在做工中，执行者 : Task 2
正在做工中，执行者 : Task 4
正在做工中，执行者 : Task 5
Process finished with exit code 0

通过上述代码，我们可以看到ThreadPoolExecutor创建了多个执行者，并同时提交了多个任务。每个执行者都会独立地执行自己的任务，并在完成后退出。这样可以有效地利用多核处理器的资源，提高任务处理的效率。

转载地址：http://gggj.baihongyu.com/