我正在编写共轭梯度方法的实现。
我使用Java多线程进行矩阵反向替换。使用CyclicBarrier、CountDownLatch进行同步。
为什么同步线程要花这么多时间？还有其他方法吗？
代码段
private void syncThreads() {
// barrier.await();
try {
barrier.await();
} catch (InterruptedException e) {
} catch (BrokenBarrierException e) {
}
}
您需要确保每个线程花费更多的时间来做有用的工作，而不是将任务传递给另一个线程的开销。
下面是一个例子，说明将任务传递给另一个线程的开销远远超过使用多个线程的好处。
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
这几乎是四倍的进步。
总共使用了多少个线程？这很可能是你问题的根源。只有在以下情况下，使用多个线程才能真正提高性能：
- 线程中的每个任务都会执行某种阻塞。例如，等待I/O。在这种情况下使用多个线程可以让其他线程使用阻塞时间
- 或者你有多个核心。如果您有4个核心或4个CPU，则可以同时执行4个任务（或4个线程）
听起来你没有阻塞线程，所以我猜你使用了太多线程。例如，如果您同时使用10个不同的线程来完成工作，但只有2个核心，那么这可能比按顺序运行所有任务慢得多。通常启动的线程数等于您的核心/CPU数。增加使用的线程，慢慢测量每次的性能。这将为您提供最佳的线程数。
也许您可以尝试使用JDK7中的fork/join来实现并重新实现您的代码，看看它能做什么？
默认情况下会创建一个线程池，其线程数量与系统中的内核数量完全相同。如果你合理地选择将工作分成小块的阈值，这可能会执行得更有效率。
你很可能知道这一点，但如果你不知道，请阅读Amdahl定律。它给出了使用并行度的程序的预期加速与程序的顺序段之间的关系。
跨核同步比单核环境慢得多，看看是否可以将jvm限制在1个核（请参阅本博客文章）
或者您可以使用ExecuterorService并使用invokeAll来运行并行任务