Question

我想学习并行编程以加速算法并选择Java 我写了两个函数来汇总数组中的long个整数 - 一个简单的迭代遍历数组，第二个 - 将数组分成几个部分，并在分离的线程中汇总部分。

我预计使用两个线程的速度大约是2倍。但是，我得到的只是加速了24％。而且，使用更多线程，我在两个线程上没有任何改进（可能少于1％）。我知道应该有线程创建/加入开销，但我想它不应该那么大。

您可以解释一下，我缺少什么或代码中的错误在哪里？这是代码：

import java.util.concurrent.ThreadLocalRandom;


public class ParallelTest {


public static long sum1 (long[] num, int a, int b) {
    long r = 0;
    while (a < b) {
        r += num[a];
        ++a;
    }
    return r;
}

public static class SumThread extends Thread {
    private long num[];
    private long r;
    private int a, b;

    public SumThread (long[] num, int a, int b) {
        super();
        this.num = num;
        this.a = a;
        this.b = b;
    }

    @Override
    public void run () {
        r = ParallelTest.sum1(num, a, b);
    }

    public long getSum () {
        return r;
    }
}


public static long sum2 (long[] num, int a, int b, int threadCnt) throws InterruptedException {
    SumThread[] th = new SumThread[threadCnt];
    int i = 0, c = (b - a + threadCnt - 1) / threadCnt;

    for (;;) {
        int a2 = a + c;
        if (a2 > b) {
            a2 = b;
        }
        th[i] = new SumThread(num, a, a2);
        th[i].start();
        if (a2 == b) {
            break;
        }
        a = a2;
        ++i;
    }

    for (i = 0; i < threadCnt; ++i) {
        th[i].join();
    }
    long r = 0;
    for (i = 0; i < threadCnt; ++i) {
        r += th[i].getSum();
    }
    return r;
}

public static void main(String[] args) throws InterruptedException {
    final int N = 230000000;
    long[] num = new long[N];

    for (int i = 0; i < N; ++i) {
        num[i] = ThreadLocalRandom.current().nextLong(1, 9999);
    }

    // System.out.println(Runtime.getRuntime().availableProcessors());

    long timestamp = System.nanoTime();
    System.out.println(sum1(num, 0, num.length));
    System.out.println(System.nanoTime() - timestamp);

    for (int n = 2; n <= 4; ++n) {
        timestamp = System.nanoTime();
        System.out.println(sum2(num, 0, num.length, n));
        System.out.println(System.nanoTime() - timestamp);
    }


}
}

编辑：我有i7处理器，有4个内核（8个线程）。代码给出的输出是：

1149914787860
175689196
1149914787860
149224086
1149914787860
147709988
1149914787860
138243999

Answer 1

我可以想出为什么你可能没有达到预期的那么快的原因。

线程创建开销很大。线程start()是一项昂贵的操作，需要多个系统调用来分配线程堆栈及其“红区”，然后创建本机线程。
N个线程不会同时启动。这意味着完成计算的并行部分的时间大约是最后一个线程的结束时间 - 第一次的开始时间。这将比一个线程完成其工作所需的时间更长。（按线程创建时间的N-1倍...）
N个线程（基本上）对阵列的N个不相交部分进行串行扫描。这是内存带宽密集型的，并且您扫描的方式意味着内存缓存将无效。因此，性能很可能受到系统主存储器硬件速度和带宽的限制。

Answer 2

该程序可能只有两个线程限制主内存带宽，因为它是一个小循环，几乎与ram可以为处理器提供数据一样快地获取数据。

Java多线程提供非常小的性能增益

2 个答案: