Java 通过多线程处理，我的搜索过程变慢了

我对并行编程这一概念还不熟悉。我试着做一个练习的方法，但是每次正常的过程都比执行中的并行过程花费更少的时间。我的实现有什么问题吗

    public class normalExecutor {

        public normalExecutor() {

        }

        public int[][] matriz = new int[3000][3000];

    public void search() {
        long startTime = System.currentTimeMillis();
        int biggest = 0;
        matriz[800][800] = 9;

        for (int i = 0 ; i < 3000; i++) {
            for (int j = 0; j < 3000; j++) {
                if(matriz[i][j] == 9) {

                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW normal "+ i + "|" + j + ": "  + elapsedTime);
                }
            }
        }


    }

}

---

谢谢

您正在一个单独的线程中运行一个非常简单和快速的执行900万次。仅仅是创建runnable来包装代码所需的时间，

ExecutorService

花时间等待可用线程并在其中运行代码所需的时间就要多得多

正确的方法是将3kx3k矩阵的迭代拆分为单独的线程。例如，给每个线程500行以进行处理。这样，您将有大约6个线程并行处理独立数据

我更改了您的代码，它显示了当您处理每行甚至需要2毫秒的执行时，并行处理的速度会有多快

但我不得不做两个改变

首先，我将带有9的单元格移到矩阵的中间，这样在正常搜索中很难快速找到它

其次，我添加了

Thread.sleep

来模拟长时间运行的执行，以证明并行处理的合理性

final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    final List<Future<?>> futures = new ArrayList<>();

    public int[][] matriz = new int[3000][3000];



    public void parallelSearch() {
        long startTime = System.currentTimeMillis();
        matriz[1580][1] = 9;

        executor.submit( () -> search( 0, 500, startTime) );
        executor.submit( () -> search( 500, 1000, startTime) );
        executor.submit( () -> search( 1000, 1500, startTime) );
        executor.submit( () -> search( 1500, 2000, startTime) );
        executor.submit( () -> search( 2000, 2500, startTime) );
        executor.submit( () -> search( 2500, 3000, startTime) );
    }

    public void search(int startRow, int endRow, long startTime){
        for (int i = startRow ; i < endRow; i++) {
            //add some execution time to justify parallel processing
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {
                int x = i;
                int z = j;

                if(matriz[x][z] == 9) {
                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW parallel "+ x + "|" + z+ ": "  + elapsedTime);
                }
            }
        }
    }

    public void search() {
        long startTime = System.currentTimeMillis();
        int biggest = 0;

        for (int i = 0 ; i < 3000; i++) {

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {

                if( matriz[i][j] == 9 ) {

                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW normal "+ i + "|" + j + ": "  + elapsedTime);
                }
            }
        }


    }

final ExecutorService executor=Executors.newFixedThreadPool（Runtime.getRuntime（）.availableProcessors（））；
最终列表您正在一个单独的线程中运行一个非常简单和快速的执行900万次。仅仅是创建runnable来包装代码所需的时间，
ExecutorService
花时间等待可用线程并在其中运行代码所需的时间就要多得多

正确的方法是将3kx3k矩阵的迭代拆分为单独的线程。例如，给每个线程500行以进行处理。这样，您将有大约6个线程并行处理独立数据

我更改了您的代码，它显示了当您处理每行甚至需要2毫秒的执行时，并行处理的速度会有多快

但我不得不做两个改变

首先，我将带有9的单元格移到矩阵的中间，这样在正常搜索中很难快速找到它

其次，我添加了
Thread.sleep
来模拟长时间运行的执行，以证明并行处理的合理性

final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    final List<Future<?>> futures = new ArrayList<>();

    public int[][] matriz = new int[3000][3000];



    public void parallelSearch() {
        long startTime = System.currentTimeMillis();
        matriz[1580][1] = 9;

        executor.submit( () -> search( 0, 500, startTime) );
        executor.submit( () -> search( 500, 1000, startTime) );
        executor.submit( () -> search( 1000, 1500, startTime) );
        executor.submit( () -> search( 1500, 2000, startTime) );
        executor.submit( () -> search( 2000, 2500, startTime) );
        executor.submit( () -> search( 2500, 3000, startTime) );
    }

    public void search(int startRow, int endRow, long startTime){
        for (int i = startRow ; i < endRow; i++) {
            //add some execution time to justify parallel processing
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {
                int x = i;
                int z = j;

                if(matriz[x][z] == 9) {
                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW parallel "+ x + "|" + z+ ": "  + elapsedTime);
                }
            }
        }
    }

    public void search() {
        long startTime = System.currentTimeMillis();
        int biggest = 0;

        for (int i = 0 ; i < 3000; i++) {

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {

                if( matriz[i][j] == 9 ) {

                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW normal "+ i + "|" + j + ": "  + elapsedTime);
                }
            }
        }


    }

final ExecutorService executor=Executors.newFixedThreadPool（Runtime.getRuntime（）.availableProcessors（））；
最终列表这不是一个并行性很好的问题，您在创建对象等方面有很多开销。多线程并不是让一切都变得更快的魔法。提示：您希望我们花时间来帮助您。因此，请您花5分钟来正确格式化/缩进所有代码。这不是一个并行性很好的问题，您在创建对象等方面有很多开销。多线程并不是让一切都变得更快的魔法。提示：您希望我们花时间来帮助您。因此，请花5分钟来正确格式化/缩进所有代码。
final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
    final List<Future<?>> futures = new ArrayList<>();

    public int[][] matriz = new int[3000][3000];



    public void parallelSearch() {
        long startTime = System.currentTimeMillis();
        matriz[1580][1] = 9;

        executor.submit( () -> search( 0, 500, startTime) );
        executor.submit( () -> search( 500, 1000, startTime) );
        executor.submit( () -> search( 1000, 1500, startTime) );
        executor.submit( () -> search( 1500, 2000, startTime) );
        executor.submit( () -> search( 2000, 2500, startTime) );
        executor.submit( () -> search( 2500, 3000, startTime) );
    }

    public void search(int startRow, int endRow, long startTime){
        for (int i = startRow ; i < endRow; i++) {
            //add some execution time to justify parallel processing
            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {
                int x = i;
                int z = j;

                if(matriz[x][z] == 9) {
                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW parallel "+ x + "|" + z+ ": "  + elapsedTime);
                }
            }
        }
    }

    public void search() {
        long startTime = System.currentTimeMillis();
        int biggest = 0;

        for (int i = 0 ; i < 3000; i++) {

            try {
                Thread.sleep(2);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

            for (int j = 0; j < 3000; j++) {

                if( matriz[i][j] == 9 ) {

                    long stopTime = System.currentTimeMillis();
                    long elapsedTime = stopTime - startTime;

                    System.out.println("NOW normal "+ i + "|" + j + ": "  + elapsedTime);
                }
            }
        }


    }