超过 2 个线程的工作速度比 1 或 2 个线程慢，除非将 Thread.sleep(1) 放入线程的 run() 方法

我正在尝试实现的任务是使用多个线程在设定的间隔内查找数字的 Collatz 序列，并查看与一个线程相比获得了多少改进。

但是，无论我是否选择 2 个线程，一个线程总是更快(编辑 2 个线程更快，但不是很多，而 4 个线程比 1 个线程慢，我不知道为什么。我甚至可以说线程越多，它的速度越慢)。我希望有人能解释一下。也许我做错了什么。

下面是我到目前为止编写的代码。我正在使用ThreadPoolExecutor来执行任务(一个任务=一个Collatz序列用于间隔中的一个数字)。

科拉茨类：

public class ParallelCollatz implements Runnable {
private long result;
private long inputNum;
public long getResult() {
return result;
}
public void setResult(long result) {
this.result = result;
}
public long getInputNum() {
return inputNum;
}
public void setInputNum(long inputNum) {
this.inputNum = inputNum;
}
public void run() {
//System.out.println("number:" + inputNum);
//System.out.println("Thread:" + Thread.currentThread().getId());
//int j=0;
//if(Thread.currentThread().getId()==11) {
//  ++j;
//  System.out.println(j);
//}
long result = 1;
//main recursive computation
while (inputNum > 1) {
if (inputNum % 2 == 0) {
inputNum = inputNum / 2;
} else {
inputNum = inputNum * 3 + 1;
}
++result;
}
// try {
//Thread.sleep(10);
//} catch (InterruptedException e) {
// TODO Auto-generated catch block
//      e.printStackTrace();
//}
this.result=result;
return;
}
}

以及我运行线程的主类(是的，现在我创建了两个具有相同数字的列表，因为在运行一个线程后，初始值丢失了)：

ThreadPoolExecutor executor = (ThreadPoolExecutor)Executors.newFixedThreadPool(1);
ThreadPoolExecutor executor2 = (ThreadPoolExecutor)Executors.newFixedThreadPool(4);
List<ParallelCollatz> tasks = new ArrayList<ParallelCollatz>();
for(int i=1; i<=1000000; i++) {
ParallelCollatz task = new ParallelCollatz();
task.setInputNum((long)(i+1000000));
tasks.add(task);
}

long startTime = System.nanoTime();
for(int i=0; i<1000000; i++) {
executor.execute(tasks.get(i));
}
executor.shutdown();
boolean tempFirst=false;
try {
tempFirst =executor.awaitTermination(5, TimeUnit.HOURS);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
System.out.println("tempFirst " + tempFirst);
long endTime = System.nanoTime();
long    durationInNano = endTime - startTime;
long    durationInMillis = TimeUnit.NANOSECONDS.toMillis(durationInNano);  //Total execution time in nano seconds
System.out.println("laikas " +durationInMillis);

List<ParallelCollatz> tasks2 = new ArrayList<ParallelCollatz>();
for(int i=1; i<=1000000; i++) {
ParallelCollatz task = new ParallelCollatz();
task.setInputNum((long)(i+1000000));
tasks2.add(task);
}

long startTime2 = System.nanoTime();
for(int i=0; i<1000000; i++) {
executor2.execute(tasks2.get(i));
}
executor2.shutdown();
boolean temp =false;
try {
temp=executor2.awaitTermination(5, TimeUnit.HOURS);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println("temp "+ temp);
long endTime2 = System.nanoTime();
long durationInNano2 = endTime2 - startTime2;
long durationInMillis2 = TimeUnit.NANOSECONDS.toMillis(durationInNano2);  //Total execution time in nano seconds
System.out.println("laikas2 " +durationInMillis2);

例如，使用一个线程运行，它在 3280ms 内完成。使用两个线程运行 3437ms。我应该考虑另一个并发结构来计算每个元素吗？

编辑澄清。我不是在尝试并行化单个序列，而是在每个数字都有其序列时的数字间隔。(与其他数字无关)

编辑2

今天，我在一台具有6个内核和12个逻辑处理器的好PC上运行该程序，但问题仍然存在。有没有人知道问题可能在哪里？我还更新了我的代码。由于某种原因，4 个线程比 2 个线程差。(甚至比 1 个线程更糟糕)。我也应用了答案中给出的内容，但没有变化。

另一个编辑我注意到，如果我在我的 ParallelCollatz 方法中放置一个 Thread.sleep(1)，那么性能会随着线程数的增加而逐渐提高。也许这个细节告诉某人出了什么问题？但是，如果没有 Thread.Sleep(1)，无论我给出多少任务，2 个线程执行速度最快 1 个线程排在第 2 位，其他线程的挂起时间相似，毫秒数相似，但都比 1 个和 2 个线程慢。

新编辑我还尝试在 Runnable 类的 run() 方法中放置更多任务(用于计算不是 1 个而是 10 或 100 个 Collatz 序列的循环)，以便线程本身可以做更多的工作。不幸的是，这也无济于事。也许我启动任务不正确？有人有什么想法吗？

编辑因此，在向run方法添加更多任务后，似乎可以稍微修复它，但是对于更多线程，问题仍然存在8+。我仍然想知道造成这种情况的原因是创建和运行线程比执行任务花费更多的时间？还是我应该用这个问题创建一个新帖子？

您不是在等待任务完成，而只是测量将它们提交给执行者所需的时间。

executor.shutdown()不会等待所有任务完成。之后您需要致电executor.awaitTermination。

executor.shutdown();
executor.awaitTermination(5, TimeUnit.HOURS);

https://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ExecutorService.html#shutdown()

更新我认为我们的测试方法是有缺陷的。我在我的机器上重复了您的测试(1 个处理器、2 个内核、4 个逻辑处理器)，并且从运行到运行测量的时间差异很大。

我认为主要原因如下：

JVM启动和JIT编译时间。一开始，代码以解释模式运行。
计算结果将被忽略。我没有直觉知道 JIT 删除了什么以及我们实际测量了什么。
代码中的打印行

为了测试这一点，我将您的测试转换为 JMH。特别：

我将可运行对象转换为可调用对象，并返回结果总和以防止内联(或者，您可以使用JMH的黑洞)
的任务没有状态，我将所有移动部分移动到局部变量。不需要 GC 来清理任务。
我仍然在每一轮中创建执行器。这并不完美，但我决定保持原样。

我在下面收到的结果与我的预期一致：一个内核在主线程中等待，工作在单个内核上执行，数字大致相同。

Benchmark                  Mode  Cnt    Score    Error  Units
SpeedTest.multipleThreads  avgt   20  559.996 ± 20.181  ms/op
SpeedTest.singleThread     avgt   20  562.048 ± 16.418  ms/op

更新的代码：

public class ParallelCollatz implements Callable<Long> {
private final long inputNumInit;
public ParallelCollatz(long inputNumInit) {
this.inputNumInit = inputNumInit;
}

@Override
public Long call() {
long result = 1;
long inputNum = inputNumInit;
//main recursive computation
while (inputNum > 1) {
if (inputNum % 2 == 0) {
inputNum = inputNum / 2;
} else {
inputNum = inputNum * 3 + 1;
}
++result;
}
return result;
}
}

以及基准测试本身：

@State(Scope.Benchmark)
public class SpeedTest {
private static final int NUM_TASKS = 1000000;
private static List<ParallelCollatz> tasks = buildTasks();
@Benchmark
@Fork(value = 1, warmups = 1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@SuppressWarnings("unused")
public long singleThread() throws Exception {
ThreadPoolExecutor executorOneThread = (ThreadPoolExecutor) Executors.newFixedThreadPool(1);
return measureTasks(executorOneThread, tasks);
}
@Benchmark
@Fork(value = 1, warmups = 1)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@SuppressWarnings("unused")
public long multipleThreads() throws Exception {
ThreadPoolExecutor executorMultipleThread = (ThreadPoolExecutor) Executors.newFixedThreadPool(4);
return measureTasks(executorMultipleThread, tasks);
}
private static long measureTasks(ThreadPoolExecutor executor, List<ParallelCollatz> tasks) throws InterruptedException, ExecutionException {
long sum = runTasksInExecutor(executor, tasks);
return sum;
}
private static long runTasksInExecutor(ThreadPoolExecutor executor, List<ParallelCollatz> tasks) throws InterruptedException, ExecutionException {
List<Future<Long>> futures = new ArrayList<>(NUM_TASKS);
for (int i = 0; i < NUM_TASKS; i++) {
Future<Long> f = executor.submit(tasks.get(i));
futures.add(f);
}
executor.shutdown();
boolean tempFirst = false;
try {
tempFirst = executor.awaitTermination(5, TimeUnit.HOURS);
} catch (InterruptedException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
long sum = 0l;
for (Future<Long> f : futures) {
sum += f.get();
}
//System.out.println(sum);
return sum;
}
private static List<ParallelCollatz> buildTasks() {
List<ParallelCollatz> tasks = new ArrayList<>();
for (int i = 1; i <= NUM_TASKS; i++) {
ParallelCollatz task = new ParallelCollatz((long) (i + NUM_TASKS));
tasks.add(task);
}
return tasks;
}
}

相关内容

最新更新

热门标签：