实例分析

如何对1~100000000的所有数进行求和，下面采用两种方法；第一种直接求和，一个for循环即可搞定，如果要从时间上来优化的话，可以使用fork/join框架从多线程上面进行优化，开启多条线程并行计算各段和并最后相加得到总结果，实现如下：

实现代码

package com.gastby.test;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class CountSumOfIntegers extends RecursiveTask<Integer>{

    /**
     * 
     */
    private static final long serialVersionUID = 1L;
    private static final int THREADHOLD = 100000000 / 8;
    private int start, end;

    public CountSumOfIntegers(int start, int end) {
        this.start = start;
        this.end = end;
    }

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        long t1 = System.currentTimeMillis();
        int sum = 0;
        for (int i=0; i<=100000000; i++)
            sum += i;
        long t2 = System.currentTimeMillis();
        System.out.println("final sum = " + sum);
        System.out.println("TimeUsage with 1 thread: " + (t2 - t1));
        ForkJoinPool fp = new ForkJoinPool();
        CountSumOfIntegers task = new CountSumOfIntegers(1, 100000000);
        Future<Integer> result = fp.submit(task);
        System.out.println("waiting .....");
        System.out.println("final sum = " + result.get());
        System.out.println("TimeUsage with 8 thread: " + (System.currentTimeMillis() - t2));
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        if (end - start <= THREADHOLD) {
            for (int i=start; i<=end; i++)
                sum += i;
        } else {
            int mid = start + (end - start) / 2;
            CountSumOfIntegers lt = new CountSumOfIntegers(start, mid);
            CountSumOfIntegers rt = new CountSumOfIntegers(mid+1, end);
            lt.fork();
            rt.fork();
            int leftsum = lt.join();
            int rightsum = rt.join();
            sum = leftsum + rightsum;
        }
        return sum;
    }
}

结果如下：

final sum = 987459712
TimeUsage with 1 thread: 37
waiting .....
final sum = 987459712
TimeUsage with 8 thread: 20

总结

• 并不是线程越多越好，因为开启的线程一一对应系统的处理器，对于4核处理器来说，最高效运行状态是每一个处理器上运行一个线程，此时最省时，而且开启线程越多，系统开销也越大，保留结果月越多份，最后系统资源读取等花销也浪费不少时间。