為什么在我的代碼中單線程比多線程快？

Question

我的代碼很慢，所以我認為我可以使用多線程來推送它。 但是當我使用多線程時它變慢了。 它用於卷積運算。 Matrix []的長度約為1到64，每個Matrix的尺寸為28x28。 同樣，Matrix [] []內核長度在第一維和第二維中為1到64，每個內核為3x3大。（Matrix.matrix是double [] []-array）

我已經嘗試使用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-與固定的線程池一起使用並安排工作程序任務，並且不要在循環內部創建線程。線程創建有其自身的開銷，這會很慢。