如何解决在Java中使用并行机制会使程序变慢慢四倍！！！
|| 我正在写共轭梯度方法的实现。 我使用Java多线程进行矩阵反向替换。 使用CyclicBarrier，CountDownLatch进行同步。 为什么要花这么多时间来同步线程？ 还有其他方法吗？ 程式码片段private void syncThreads() {
// barrier.await();
try {
barrier.await();
} catch (InterruptedException e) {
} catch (BrokenBarrierException e) {
}
}
解决方法
总共使用了多少个线程？那可能是您问题的根源。使用多个线程只会在以下情况下真正提高性能：
线程中的每个任务都会执行某种阻塞。例如，等待I / O。在这种情况下使用多个线程可以使阻塞时间被其他线程使用。
或者您有多个核心。如果您有4个核心或4个CPU，则可以同时执行4个任务（或4个线程）。
听起来您没有阻塞线程，所以我猜您正在使用太多线程。例如，如果您使用10个不同的线程同时执行工作，但只有2个内核，则这可能比按顺序运行所有任务要慢得多。通常，启动的线程数等于您的内核/ CPU数。每次缓慢增加使用的线程，以衡量性能。这将为您提供最佳的线程数以供使用。
, 您需要确保每个线程花费更多的时间进行有用的工作，而不是将任务传递给另一个线程的开销。
这是一个将任务传递给另一个线程的开销远远大于使用多个线程的好处的示例。
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
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。