Java ThreadPool 限制创建的最大线程数

Question

我正在尝试编写一个 Java 多线程程序，对作为文件给出的 2 个矩阵执行乘法，并使用有限的线程总数。

例如，如果我将线程数设置为 16，我希望我的线程池能够重用这 16 个线程，直到所有任务完成。

但是，对于更多数量的线程，我最终会获得更长的执行时间，并且我很难理解为什么。

可运行:

class Task implements Runnable
{
    int _row = 0;
    int _col = 0;

    public Task(int row, int col)
    {
        _row = row;
        _col = col;
    }

    @Override
    public void run()
    {
        Application.multiply(_row, _col);
    }
}

应用:

public class Application
{
    private static Scanner sc = new Scanner(System.in);

    private static int _A[][];
    private static int _B[][];
    private static int _C[][];

    public static void main(final String [] args) throws InterruptedException
    {                
        ExecutorService executor = Executors.newFixedThreadPool(16);
        ThreadPoolExecutor pool = (ThreadPoolExecutor) executor;

        _A = readMatrix();
        _B = readMatrix();
        _C = new int[_A.length][_B[0].length];

        long startTime = System.currentTimeMillis();
        for (int x = 0; x < _C.length; x++)
        {
            for (int y = 0; y < _C[0].length; y++)
            {
                executor.execute(new Task(x, y));
            }
        }
        long endTime = System.currentTimeMillis();

        executor.shutdown();
        executor.awaitTermination(Long.MAX_VALUE, TimeUnit.HOURS);

        System.out.printf("Calculation Time: %d ms\n" , endTime - startTime);
   }

    public static void multMatrix(int row, int col)
    {
        int sum = 0;
        for (int i = 0; i < _B.length; i++)
        {
            sum += _A[row][i] * _B[i][col];
        }
        _C[row][col] = sum;
    }

    ...
}

矩阵计算和工作负载共享似乎是正确的，因此可能是由于 ThreadPool 使用不当造成的

Answer 1

上下文切换需要时间。如果您有 8 个核心并且正在执行 8 个线程，那么它们都可以同时工作，并且一旦一个线程完成，它将被重用。另一方面，如果您有 8 个核心的 16 个线程，每个线程将竞争处理器时间，调度程序将切换这些线程，您的时间将增加到 - 执行时间 + 上下文切换。

线程越多，上下文切换就越多，因此时间也会增加。