Question

我正在编写共轭梯度法实现。

我使用Java多线程进行矩阵反向替换。使用CyclicBarrier，CountDownLatch进行同步。

为什么同步线程需要这么多时间？还有其他方法吗？

代码段

private void syncThreads() {

    // barrier.await();

    try {

        barrier.await();

    } catch (InterruptedException e) {

    } catch (BrokenBarrierException e) {

    }

}

Answer 1

总共使用了多少个线程？这可能是你问题的根源。使用多个线程只会在以下情况下提高性能：

线程中的每个任务都会进行某种阻塞。例如，等待I / O.在这种情况下使用多个线程可以使阻塞时间被其他线程使用。
或您有多个核心。如果您有4个内核或4个CPU，则可以同时执行4个任务（或4个线程）。

听起来你没有在线程中阻塞所以我猜你是在使用太多的线程。例如，如果您使用10个不同的线程同时执行工作但只有2个核心，则可能比按顺序运行所有任务要慢得多。通常启动线程数等于核心/ CPU数量。每次增加缓慢使用的线程。这将为您提供最佳的线程数。

Answer 2

您需要确保每个线程花费更多时间来完成有用的工作，而不是花费额外的成本将任务传递给另一个线程。

以下是将任务传递给另一个线程的开销远远超过使用多个线程的好处的示例。

final double[] results = new double[10*1000*1000];
{
    long start = System.nanoTime();
    // using a plain loop.
    for(int i=0;i<results.length;i++) {
        results[i] = (double) i * i;
    }
    long time = System.nanoTime() - start;
    System.out.printf("With one thread it took %.1f ns per square%n", (double) time / results.length);
}
{
    ExecutorService ex = Executors.newFixedThreadPool(4);
    long start = System.nanoTime();
    // using a plain loop.
    for(int i=0;i<results.length;i++) {
        final int i2 = i;
        ex.execute(new Runnable() {
            @Override
            public void run() {
                results[i2] = i2 * i2;

            }
        });
    }
    ex.shutdown();
    ex.awaitTermination(1, TimeUnit.MINUTES);
    long time = System.nanoTime() - start;
    System.out.printf("With four threads it took %.1f ns per square%n", (double) time / results.length);
}

打印

With one thread it took 1.4 ns per square
With four threads it took 715.6 ns per square

使用多线程要糟糕得多。

但是，增加每个线程的工作量和

final double[] results = new double[10 * 1000 * 1000];
{
    long start = System.nanoTime();
    // using a plain loop.
    for (int i = 0; i < results.length; i++) {
        results[i] = Math.pow(i, 1.5);
    }
    long time = System.nanoTime() - start;
    System.out.printf("With one thread it took %.1f ns per pow 1.5%n", (double) time / results.length);
}
{
    int threads = 4;
    ExecutorService ex = Executors.newFixedThreadPool(threads);
    long start = System.nanoTime();
    int blockSize = results.length / threads;
    // using a plain loop.
    for (int i = 0; i < threads; i++) {
        final int istart = i * blockSize;
        final int iend = (i + 1) * blockSize;
        ex.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = istart; i < iend; i++)
                    results[i] = Math.pow(i, 1.5);
            }
        });
    }
    ex.shutdown();
    ex.awaitTermination(1, TimeUnit.MINUTES);
    long time = System.nanoTime() - start;
    System.out.printf("With four threads it took %.1f ns per pow 1.5%n", (double) time / results.length);
}

打印

With one thread it took 287.6 ns per pow 1.5
With four threads it took 77.3 ns per pow 1.5

这几乎提高了4倍。

Answer 3

也许您可以尝试使用来自JDK 7的fork / join重新实现代码并查看它的作用？

默认情况下会创建一个线程池，其线程数与系统中的内核数量完全相同。如果您选择合理地将工作划分为较小块的阈值，则可能会执行效率更高。

Answer 4

您很可能意识到这一点，但如果您不这样做，请阅读Amdahl's Law。它通过使用并行性和程序的连续段来给出程序的预期加速之间的关系。

Answer 5

跨核心同步比单个核心环境慢得多，看看你是否可以将jvm限制为1核心（参见this blog post）

或者您可以使用ExecuterorService并使用invokeAll来运行并行任务

在Java中使用并行性会使程序变慢（慢四倍!!!）

5 个答案: