大约。用于比较Java中的顺序V/S并行速度。为什么.parallel（）比较慢？

Question

我正在使用一个非常著名的圆环近似值的例子。我选取单位正方形（（0,0）到（1,1））中的随机点，看看有多少随机点落在单位圆的区域内。分数应为？/4的值。

public class PIEstimation {
    final static int NUM_SAMPLES = 100000000;

    public static void main(String[] args) {

    sequentialVersion();
    parallelVersion();
    System.out.println("               Real PI:= " + Math.PI);
    }

    public static void sequentialVersion() {
    final long start = System.nanoTime();

    final long count = LongStream
        .rangeClosed(1, NUM_SAMPLES)
        .filter(e -> {
                double x = Math.random();
                double y = Math.random();
                return x * x + y * y < 1;
    }).count();

    final long duration = ((System.nanoTime() - start) / 1_000_000);

    System.out.println("Sequential Version: PI ~ " + 4.0 * (count / (double) NUM_SAMPLES) + " calculated in "
        + duration + " msecs");
    }

    public static void parallelVersion() {
    final long start = System.nanoTime();

    final long count = LongStream
        .rangeClosed(1, NUM_SAMPLES)
        .parallel()
        .filter(e -> {
                double x = Math.random();
                double y = Math.random();
                return x * x + y * y < 1;
    }).count();

    final long duration = ((System.nanoTime() - start) / 1_000_000);

    System.out.println("  Parallel Version: PI ~ " + 4.0 * (count / (double) NUM_SAMPLES) + " calculated in "
        + duration + " msecs");
    }

}

结果：

Sequential Version: PI ~ 3.14176568 calculated in  4893 msecs
  Parallel Version: PI ~ 3.1417546  calculated in 12044 msecs
               Real PI:= 3.141592653589793

Answer 1

在我的机器上并行运行(3.0GHz英特尔酷睿i7，两个核心，四个线程）得到的结果更糟：

sequential: PI ~ 3.14175124 calculated in  4952 msecs
  parallel: PI ~ 3.14167776 calculated in 21320 msecs

我怀疑主要原因是math.random()是线程安全的，因此它会在每个调用周围同步。因为有多个线程同时尝试获取随机数，所以它们都在争夺同一个锁。这增加了大量的开销。请注意，math.random()的规范说明如下：

此方法已正确同步，以允许多个线程正确使用。然而，如果许多线程需要以很高的速率生成伪随机数，那么每个线程拥有自己的伪随机数生成器可以减少争用。

long count = LongStream.rangeClosed(1, NUM_SAMPLES)
                       .parallel()
                       .filter(e -> {
                           ThreadLocalRandom cur = ThreadLocalRandom.current();
                           double x = cur.nextDouble();
                           double y = cur.nextDouble();
                           return x * x + y * y < 1;
                       })
                       .count();

sequential2: PI ~ 3.14169156 calculated in 1171 msecs
  parallel2: PI ~ 3.14166796 calculated in  648 msecs

这是1.8倍的加速比，对于一个双核的机器来说还不算太差。请注意，当按顺序运行时，这也会更快，可能是因为没有任何锁开销。

旁白：通常情况下，对于基准测试，我建议使用JMH。然而，这个基准似乎运行得足够长，它给出了相对速度的合理指示。为了得到更精确的结果，我推荐使用JMH。

更新

NUM_SAMPLES = 100_000_000

sequential:  PI ~ 3.14175124 calculated in    4952 msecs
parallel:    PI ~ 3.14167776 calculated in   21320 msecs
sequential2: PI ~ 3.14169156 calculated in    1171 msecs
parallel2:   PI ~ 3.14166796 calculated in     648 msecs

NUM_SAMPLES = 1_000_000_000

sequential:  PI ~ 3.141572896 calculated in  47730 msecs
parallel:    PI ~ 3.141543836 calculated in 228969 msecs
sequential2: PI ~ 3.1414865   calculated in  12843 msecs
parallel2:   PI ~ 3.141635704 calculated in   7953 msecs