java - Java 中的线程 - N 个数字的总和

Question

我尝试使用常规方法执行 N 个数字的求和，并使用线程来查看线程的性能。我发现传统方法比基于线程的方法运行得更快。我的计划是将上限(N)分解为多个范围，然后为每个范围运行一个线程，最后添加每个线程计算出的总和。

stats in milliseconds :

248
500000000500000000
-----same with threads------
498
500000000500000000

在这里，我看到使用线程的方法花费了约 500 毫秒，而传统方法仅花费了约 250 秒。我想知道我是否正确地实现了这个问题的线程。谢谢

代码:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyThread implements Runnable {
    private int from , to , sum;

    public MyThread(long from , long to) {
        this.from = from;
        this.to = to;
        sum = 0;
    }

    public void run() {
        for(long i=from;i<=to;i++) {
            sum+=i;
        }
    }

    public long getSum() {
        return this.sum;
    }
}


public class exercise {

    public static void main(String args[]) {

        long startTime = System.currentTimeMillis();

        long sum = 0;
        for(long i=1;i<=1000000000;i++) {
            sum+=i;
        }

        long endTime = System.currentTimeMillis();

        long duration = (endTime - startTime);  //Total execution time in milli seconds

        System.out.println(duration);

        System.out.println(sum);



        System.out.println("-----same with threads------");

        ExecutorService executor = Executors.newFixedThreadPool(5);

        MyThread one = new MyThread(1, 100000);
        MyThread two = new MyThread(100001, 10000000);
        MyThread three = new MyThread(10000001, 1000000000);

        startTime = System.currentTimeMillis();


        executor.execute(one);
        executor.execute(two);
        executor.execute(three);

        executor.shutdown();

        // Wait until all threads are finish
        while (!executor.isTerminated()) {

        }

        endTime = System.currentTimeMillis();

        System.out.println(endTime - startTime);

        long thsum = one.getSum() + two.getSum() + three.getSum();

        System.out.println(thsum);
    }
}

Answer 1

只有当为每个线程分配相同的工作量时，将工作拆分为多个线程才有意义。

在您的例子中，第一个线程几乎不执行任何操作，第二个线程执行几乎 1% 的工作，第三个线程执行 99% 的工作。

因此，您需要支付运行多个线程的开销，而无法从并行执行中受益。

按如下方式平均分配工作应该会产生更好的结果:

MyThread one = new MyThread(1, 333333333);
MyThread two = new MyThread(333333334, 666666667);
MyThread three = new MyThread(666666668, 1000000000);