使用executor、callable以及一个Future 计算欧拉数e

package test;

import java.math.BigDecimal;

import java.math.MathContext;

import java.math.RoundingMode;

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.Future;

public class CaculateE {

    final static int num=17;

    public static void main(String[] args) {

        // TODO Auto-generated method stub

        //使用线程池防止多条人物提交而创建的线程

        ExecutorService executor=Executors.newFixedThreadPool(1);

        Callable<BigDecimal> callable=new Callable<BigDecimal>() {

            @Override

            public BigDecimal call() throws Exception {

                // TODO Auto-generated method stub

                //舍位模式,四舍五入，100为e的精度上限

                MathContext mc=new MathContext(100,RoundingMode.HALF_UP);

                BigDecimal result=BigDecimal.ZERO;

                //e=1/0!+1/1!+1/2!+1/3!+...+...

                for(int i=0;i<num;i++) {

                    //factory()表示阶乘的结果    new BigDecimal() 确保结果精确,防止精度丢失

                    BigDecimal factorial=factory(new BigDecimal(i));

                    System.out.println("factorial:"+factorial);

                    //1除以factorial的阶乘

                    BigDecimal res=BigDecimal.ONE.divide(factorial,mc);

                    System.out.println("res:"+res);

                    result=result.add(res);

                    System.out.println("result:"+result);

                }

                return result;

            }

            //不用该方法进行转换会报执行异常

            private BigDecimal factory(BigDecimal n) {

                // TODO Auto-generated method stub

                System.err.println("n的值为："+n);

                if(n.equals(BigDecimal.ZERO)) {

                    return BigDecimal.ONE;

                }

                else {

                    //subtract(n.subtract(BigDecimal.ONE)) 对象中的值相减

                    return n.multiply(factory(n.subtract(BigDecimal.ONE)));}

            }

        };

        //提交一个runable任务进行执行，同时返回一个代表此任务的Future实例

        Future<BigDecimal> taskFuture =executor.submit(callable);

        try {

            //判断任务是否完成,模拟任务执行,未完成输出waiting,完成之后直接输出结果

            while(!taskFuture.isDone())

                System.out.println("waiting/");

                //线程执行之后可以获取结果

                //Callable接口代表一段可以调用并返回结果的代码;Future接口表示异步任务，是还没有完成的任务给出的未来结果。所以说Callable用于产生结果，Future用于获取结果。

                System.out.println("taskFuture的get()方法"+taskFuture.get());

        }catch(ExecutionException e){

                System.err.println("哦豁，抛出执行异常了！");

        }catch (InterruptedException ie) {

            // TODO Auto-generated catch block

            ie.printStackTrace();

            System.err.println("interrupted while waiting");

        }

        executor.shutdown();

    }

}

代码执行流程：

main()方法调用Excutors的newFixedThreadPool方法获取一个executor.之后初始化实现了Callable接口的匿名类并且将这个任务提交给executor,在返回接收一个Future的实例。

通过isDone（）判断是否执行完毕，’waiting‘表示一直在执行，当执行完毕，直接通过 taskFuture.get()获取计算的结果。

阶乘求值过程（包含一个递归）：

return n.multiply(factory(n.subtract(BigDecimal.ONE)));
例如：5*factory(4)
   =>5*4*factory(3）
   =>5*4*3*factory(2）
    =>5*4*3*2*factory(1)
    =>5*4*3*2*1*factory(0)
    =>120

i	0	1	2	3	4	5	6	...	16
返回值	factor(0)	1*factory(0)	2*factory(1)	3*factory(2)	4*factory(3)	5*factory(4)	6*factory(5)	...	16*factory(15)
factorial	factory(0)	1*factory(0)	2*1*factory(0)	3*2*1*factory(0)	4*3*2*factory(0)	5*4*3*2*factory(0)	6*5*4*3*2*factory(0)	...	16*15*..*2*factory(0)
factorial	1	1	2	6	12	60	120	...	16*15*..*2*factory(0)
res	1/1	1/1+1/1	1/1+1/1+1/2	1/1+1/1+1/2+1/6	1/1+1/1+1/2+1/6+1/12	1/1+1/1+1/2+1/6+1/12+1/60	1/1+1/1+1/2+1/6+1/12+1/60+1/120	...	1/1+...+1/16*15*..*2*1

ps:增加精度和num的值以求更长的收敛时间和更为接近的e