java - 为什么我的代码中单线程比多线程更快？

Question

我的代码非常慢，所以我想我可以用多线程来插入它。但当我使用多线程时，它变得更慢。它用于卷积运算。 Matrix[]的长度约为1到64，每个Matrix的大小为28x28。此外，Matrix[][] 内核长度在第一维和第二维中均为 1 到 64，每个内核大小为 3x3。(Matrix.matrix 是一个 double[][] 数组)

我已经尝试过使用 Executorservice，但出现了同样的问题。

public static Matrix[] convolve(Matrix[] in, Matrix[][] kernel) {

    // Defining size of output matrix
    int kr = kernel[0][0].rows - 1;
    int kc = kernel[0][0].cols - 1;

    Matrix[] out = new Matrix[kernel.length];

    for (int i = 0; i < kernel.length; i++) {
        out[i] = new Matrix(in[0].rows - kr, in[0].cols - kc);
    }

    // Convolution operation
    for (int i = 0; i < out[0].rows; i++) {
        for (int j = 0; j < out[0].cols; j++) {

            for (int m = 0; m < kernel.length; m++) { // Size of filters
                double sum = 0;
                for (int n = 0; n < kernel[m].length; n++) { // Depth of filters
                    for (int k = 0; k < kernel[m][n].rows; k++) { // Stride over
                        for (int l = 0; l < kernel[m][n].cols; l++) { // Stride over
                            sum += in[n].matrix[i + k][j + l] * kernel[m][n].matrix[k][l];
                        }
                    }
                }
                out[m].matrix[i][j] = sum;
            }

        }
    }

    return out;
}

public Matrix[] convolveWithThreads(Matrix[] in, Matrix[][] kernel) {
    // Defining size of output matrix
    int kr = kernel[0][0].rows - 1;
    int kc = kernel[0][0].cols - 1;

    Matrix[] out = new Matrix[kernel.length];

    for (int i = 0; i < kernel.length; i++) {
        out[i] = new Matrix(in[0].rows - kr, in[0].cols - kc);
    }
    ArrayList<Thread> ar = new ArrayList<>();
    // Convolution Operation
    for (int t = 0; t < kernel.length; t++) {
        final int m = t;
        Thread th = new Thread(new Runnable() {

            @Override
            public void run() {
                for (int i = 0; i < out[0].rows; i++) {
                    for (int j = 0; j < out[0].cols; j++) {

                        double sum = 0;
                        for (int n = 0; n < kernel[m].length; n++) { // Depth of filters
                            for (int k = 0; k < kernel[m][n].rows; k++) { // Stride over
                                for (int l = 0; l < kernel[m][n].cols; l++) { // Stride over
                                    sum += in[n].matrix[i + k][j + l] * kernel[m][n].matrix[k][l];
                                }
                            }
                        }
                        out[m].matrix[i][j] = sum;
                    }
                }
            }
        });
        th.start();
        ar.add(th);
    }

    for (Thread t : ar) {
        try {
            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    return out;
}

}

没有线程的情况下，它可以在五分钟内执行 70000 次操作，而使用线程的情况下，它只能执行 40000 次操作。 (Matrix[] 长度 = 8，Matrix[][] 内核长度 = 8 和 8)

Answer 1

生成线程并运行线程有其自身的开销并消耗资源。因此，它会减慢您的程序，否则该程序将在单线程中执行。

例如:如果您的程序由于阻塞操作而变慢，那么使用线程会减少总体执行时间。

注意:使用具有固定线程池的 executorservice- 并调度工作任务，并且不要在循环内创建线程。线程创建有其自身的开销，速度会很慢。