6

我正在尝试执行一个简单的计算（它调用Math.random()10000000 次）。令人惊讶的是，以简单的方法运行它比使用 ExecutorService 快得多。

我在ExecutorService 令人惊讶的性能收支平衡点上阅读了另一个线程 --- 经验法则？并尝试通过执行Callable使用批处理来遵循答案，但性能仍然很差

如何根据我当前的代码提高性能？

import java.util.*;
import java.util.concurrent.*;

public class MainTest {
    public static void main(String[]args) throws Exception {
        new MainTest().start();;
    }

    final List<Worker> workermulti = new ArrayList<Worker>();
    final List<Worker> workersingle = new ArrayList<Worker>();
    final int count=10000000;

    public void start() throws Exception {
        int n=2;

        workersingle.add(new Worker(1));
        for (int i=0;i<n;i++) {
            // worker will only do count/n job
            workermulti.add(new Worker(n));
        }

        ExecutorService serviceSingle = Executors.newSingleThreadExecutor();
        ExecutorService serviceMulti = Executors.newFixedThreadPool(n);
        long s,e;
        int tests=10;
        List<Long> simple = new ArrayList<Long>();
        List<Long> single = new ArrayList<Long>();
        List<Long> multi = new ArrayList<Long>();

        for (int i=0;i<tests;i++) {
            // simple
            s = System.currentTimeMillis();
            simple();
            e = System.currentTimeMillis();
            simple.add(e-s);

            // single thread
            s = System.currentTimeMillis();
               serviceSingle.invokeAll(workersingle); // single thread
            e = System.currentTimeMillis();
            single.add(e-s);

            // multi thread
            s = System.currentTimeMillis();
               serviceMulti.invokeAll(workermulti);
            e = System.currentTimeMillis();
            multi.add(e-s);
        }
        long avgSimple=sum(simple)/tests;
        long avgSingle=sum(single)/tests;
        long avgMulti=sum(multi)/tests;
        System.out.println("Average simple: "+avgSimple+" ms");
        System.out.println("Average single thread: "+avgSingle+" ms");
        System.out.println("Average multi thread: "+avgMulti+" ms");

        serviceSingle.shutdown();
        serviceMulti.shutdown();
    }

    long sum(List<Long> list) {
        long sum=0;
        for (long l : list) {
            sum+=l;
        }
        return sum;
    }

    private void simple() {
        for (int i=0;i<count;i++){
            Math.random();
        }
    }

    class Worker implements Callable<Void> {
        int n;

        public Worker(int n) {
            this.n=n;
        }

        @Override
        public Void call() throws Exception {
            // divide count with n to perform batch execution
            for (int i=0;i<(count/n);i++) {
                Math.random();
            }
            return null;
        }
    }
}

此代码的输出

Average simple: 920 ms
Average single thread: 1034 ms
Average multi thread: 1393 ms

编辑：由于 Math.random() 是一种同步方法，性能受到影响。在为每个线程使用新的 Random 对象更改 Math.random() 后，性能得到了提高

新代码的输出（在将每个线程的 Math.random() 替换为 Random 之后）

Average simple: 928 ms
Average single thread: 1046 ms
Average multi thread: 642 ms
4

3 回答 3

13

Math.random()是同步的。同步的全部意义在于减慢速度，以免它们发生冲突。使用不同步的东西和/或给每个线程它自己的对象来使用，比如一个新的Random。

于 2011-08-23T02:20:20.923 回答
4

你最好阅读另一个线程的内容。里面有很多好的技巧。

也许您的基准测试中最重要的问题是，根据 Math.random() 合同，“此方法已正确同步以允许多个线程正确使用。但是，如果许多线程需要以很高的速率生成伪随机数，它可以减少每个线程有自己的伪随机数生成器的争用"

将其解读为：该方法是同步的，因此可能只有一个线程能够同时有效地使用它。所以你做了一堆开销来分配任务，只是为了迫使它们再次串行运行。

于 2011-08-23T02:25:18.333 回答
1

当您使用多个线程时，您需要注意使用额外线程的开销。您还需要确定您的算法是否具有可以并行执行的工作。所以你需要有足够大的可以同时运行的工作，它会超过使用多个线程的开销。

在这种情况下，最简单的解决方法是在每个线程中使用单独的 Random。您遇到的问题是，作为一个微基准，您的循环实际上并没有做任何事情，而 JIT 非常擅长丢弃不做任何事情的代码。一种解决方法是对随机结果求和并从中返回它，call()因为这通常足以防止 JIT 丢弃代码。

最后，如果您想对大量数字求和，则无需保存它们并在以后对它们进行求和。您可以随时总结它们。

于 2011-08-23T08:12:23.033 回答