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-与固定线程池一起使用并安排工作程序任务，并且不要在循环内部创建线程。线程创建有其自身的开销，这会很慢。

为什么在我的代码中单线程比多线程快？

1 个答案: