java - 范围求和多线程

Question

我的程序试图将一个范围与给定数量的线程相加，以便并行运行它，但似乎只有一个线程比 4 个线程运行得更好(我有一个 8 核 CPU)。这是我第一次在 Java 中使用多线程，所以我的代码中是否存在问题导致它需要更长的时间？

我目前完成的基准测试(范围 0-10000 的总和)是:

1 个线程:1350 微秒(平均)2 线程:1800 微秒(平均)4 线程:2400 微秒(平均)8 线程:3300 微秒(平均)

提前致谢!

/*
Compile: javac RangeSum.java
Execute: java RangeSum nThreads initRange finRange
*/

import java.util.ArrayList;
import java.util.concurrent.*;

public class RangeSum implements Runnable {

private int init;
private int end; 
private int id;
static public int out = 0;

Object lock = new Object();

public synchronized static void increment(int partial) {
    out = out + partial;
}

public RangeSum(int init,int end) { 
    this.init = init;
    this.end = end;
}//parameters to pass in threads

// the function called for each thread
public void run() {
    int partial = 0;

    for(int k = this.init; k < this.end; k++)
    {
        partial = k + partial + 1;
    }
    increment(partial);
}//thread: sum its id to the out variable

public static void main(String args[]) throws InterruptedException {
    final long startTime = System.nanoTime()/1000;//start time: microsecs

    //get command line values for
    int NumberOfThreads = Integer.valueOf(args[0]);
    int initRange = Integer.valueOf(args[1]);
    int finRange = Integer.valueOf(args[2]);
    //int[] out = new int[NumberOfThreads];

    // an array of threads
    ArrayList<Thread> Threads = new ArrayList<Thread>(NumberOfThreads);

    // spawn the threads / CREATE
    for (int i = 0; i < NumberOfThreads; i++) {
        int initial = i*finRange/NumberOfThreads;
        int end = (i+1)*finRange/NumberOfThreads;
        Threads.add(i, new Thread(new RangeSum(initial,end)));
        Threads.get(i).start();
    }

    // wait for the threads to finish / JOIN
    for (int i = 0; i < NumberOfThreads; i++) {
        try {
            Threads.get(i).join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    System.out.println("All threads finished!");

    System.out.println("Total range sum: " + out);

    final long endTime = System.nanoTime()/1000;//end time
    System.out.println("Time elapsed: "+(endTime - startTime));
}
}

Answer 1

您的工作量完全在内存非阻塞计算中——根据一般原则，在这种情况下，单线程将比多线程更快地完成工作。

多线程往往会干扰 L1/L2 CPU 缓存并为上下文带来额外开销切换

具体来说，对于您的代码，您过早地初始化了 final long startTime = System.nanoTime()/1000; 并测量了线程设置时间以及它们完成所需的实际时间。最好先设置您的 Threads 列表，然后:

final long startTime =...
for (int i = 0; i < NumberOfThreads; i++) {
    Thread.get(i).start()
}

但实际上，在这种情况下，多线程将改善处理时间的期望是没有根据的。