Как уменьшить сложность времени

Question

Как я могу сократить время выполнения всего задания l oop? По какой-то причине мне пришлось использовать sleep (8) миллисекунды. SO, чтобы завершить все циклы, требуется больше 2 часов в процессоре CORE i7 и 8 ГБ ОЗУ P C. Я новичок в этой области.

        ExecutorService executorService = Executors.newCachedThreadPool();
        //Task One
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                for (int i = 1; i <= 8; i++) {
                    for (int j = 1; j <= 10; j++) {
                        for (int k = 1; k <= 1200; k++) {
                            for (int l = 1; l <= 10; l++) {
                                try {
                                    Thread.sleep(8);
                                } catch (InterruptedException ex) {
                                    ex.printStackTrace();
                                }
                                System.out.println("Task  # A:" + i + " AF: " + j + " C:" + k + " CF:" + l);
                            }
                        }
                    }
                }
            }
        });

Я пытаюсь по-другому. Это правильный способ сократить время? или предложи мне что нибудь получше.

public class Ask1 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Total customer 1200
        //1-400 for 
        System.out.println("customer range 1 to 400");
        executorService.execute(new TaskThread(2,10,400)); 
        //401 - 800 
        System.out.println("customer range 401 to 800");
        executorService.execute(new TaskThread(2,10,400));
        //801-1200
        System.out.println("customer range 801 to 1200");
        executorService.execute(new TaskThread(2,10,400));

        executorService.shutdown();
    }
}

class AskThread implements Runnable {

    int agent;
    int finger;
    int customer;

    public AskThread(int agent, int finger,int customer){
        this.agent = agent;
        this.finger = finger;
        this.customer = customer;
    }

    @Override
    public void run() {
        for (int i = 1; i <= agent; i++) { //changeable
            for (int j = 1; j <= finger; j++) { //fixed
                for (int k = 1; k <= customer; k++) { //changeable
                    for (int l = 1; l <= finger; l++) { //fixed
                        try {
                            Thread.sleep(1);
                        } catch (InterruptedException ex) {
                            ex.printStackTrace();
                        }
                        System.out.println("Task One # Agent:" + i + " Agent Finger: " + j + " Customer:" + k + " Customer Finger:" + l);
                    }
                }
            }
        }
    }
}

Answer 1

Давайте немного расширим мой комментарий. Как я уже сказал, приведенный вами пример слишком абстрактен, чтобы дать какой-то конкретный c совет, как улучшить производительность.

Из того, что я могу сказать, вы хотели распределить работу поровну между несколькими потоками. В большинстве случаев вы не можете просто разделить все «размеры» на x при создании потоков x.

Представьте себе более конкретную задачу: у вас есть двумерная матрица, представляющая шахматную доску. Вы хотите перебрать все элементы матрицы и выполнить некоторые операции. В итоге у вас получится цикл, похожий на этот:

for (int i = 0; i < dim1; i++){
  for (int j = 0; j < dim2; j++){
    \\do something here
  }
}

В этом примере нам нужно перебрать dim1 * dim2 элементов.

Допустим, мы хотим разделить работу между 4 потоки. Если вы разделите dim1 и dim2 на 4, вы получите матрицу 4 на 4, то есть 16 частей. Это наиболее заметно, когда вы представляете себе физическую шахматную доску.

Если у вас есть 4 потока, вы должны разделить работу на 4 (обычно равные) части. В этом случае вы можете либо разделить dim1 и dim2 на 2, всего 4 детали, либо только одно измерение на 4.

Редактировать. Вероятно, то же самое относится и к вашей проблеме. Если у вас есть x агентов, у каждого по 20 пальцев, а у y клиентов по 20 пальцев, вы, вероятно, захотите сравнить каждого с каждым.

Для 4 потоков вы не можете просто взять 1/4 агентов, 1/4 их пальцев и сравнить с какой-то частью клиентов - и только 1/4 их пальцев. Все, что вы можете сделать, это взять 1/4 агентов, все 20 их пальцев и сравнить со всеми пальцами всех клиентов.