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

Question

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

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

下面是我到目前为止编写的代码。我使用 ThreadPoolExecutor 来执行任务(一个任务 = 一个 Collat​​z 序列，对应间隔中的一个数字)。

Collat​​z 类:

    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);

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

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

编辑2

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

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

新编辑我还尝试在 Runnable 类的 run() 方法中放置更多任务(用于计算不是 1 个而是 10 或 100 个 Collat​​z 序列的循环)，以便线程本身可以完成更多工作。不幸的是，这也没有帮助。也许我错误地启动了任务？大家有什么想法吗？

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

Answer 1

您并不是等待任务完成，而是测量将任务提交给执行器所需的时间。

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 的 BlackHole)
• 我的任务没有状态，我将所有移动部分移至局部变量。不需要 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;
    }

}