description

lyakhov_timofey_lab_1/README.md

@@ -45,6 +45,93 @@
     2. **ThreadPool** — распределение строк по пулу потоков.
     3. **ForkJoinPool** — разбиение задачи на подзадачи с использованием `RecursiveTask`.
 - Для каждого способа выводит время выполнения в наносекундах.
+```java
+
+    public static void calculateSumOfRow() { // Фнукция подсчета в одном потоке
+        LocalDateTime startTime = LocalDateTime.now();
+        long s = System.nanoTime();
+        int sum = 0;
+        for (int[] ints : matrix) {
+            int product = 1;
+            for (int anInt : ints) {
+                product *= anInt;
+            }
+            sum += product;
+        }
+
+        long st = System.nanoTime() - s;
+        System.out.println("Время выполнения в одном потоке: \t" + st);
+
+    }
+
+    public static void calculateSumOfRowWithThreadPool() { // Фнукция подсчета с помощью  ThreadPool
+        int sum = 0;
+        int numThreads = Runtime.getRuntime().availableProcessors(); // Определение количества потоков на основании процессора
+        ExecutorService executor = Executors.newFixedThreadPool(numThreads);
+        List<Future<Integer>> futures = new ArrayList<>();
+        long s = System.nanoTime();
+        for (int i = 0; i < matrix.length; i++) { // Создание задач выполнения
+            final int row = i;
+            futures.add(executor.submit(() -> {
+                int product = 1;
+                for (int j = 0; j < matrix[row].length; j++) {
+                    product *= matrix[row][j];
+                }
+                return product;
+            }));
+        }
+
+        for (Future<Integer> future : futures) { // Подсчет всех значений
+            try {
+                sum += future.get();
+            } catch (InterruptedException | ExecutionException e) {
+                System.out.println(e.getMessage());
+            }
+        }
+
+        executor.shutdown();
+
+        long st = System.nanoTime() - s;
+        System.out.println("Время выполнения с ThreadPool: \t\t" + st);
+    }
+
+    public static void calculateSumOfRowWithForkPool(){ // ПОдсчет через ForkPool
+
+        PartTask pt = new PartTask(matrix, 0, size + 1); // Создание сущности парта
+        ForkJoinPool forkJoinPool = new ForkJoinPool(); 
+        long s = System.nanoTime();
+        forkJoinPool.invoke(pt);
+        long st = System.nanoTime() - s;
+        System.out.println("Время выполнения с ForkJoinPool: \t" + st);
+    }
+
+}
+class PartTask extends RecursiveTask<Integer> { // Класс задачи
+
+    private final int[][] matrix;
+    private final int start, stop;
+
+    public PartTask(int[][] matrix, int start, int stop) {
+        this.matrix = matrix;
+        this.start = start;
+        this.stop = stop;
+    }
+
+    @Override
+    protected Integer compute() { // Вычисление части парта(Использование рекурсий)
+        if (start + 1 == stop) {
+            return Arrays.stream(matrix[start]).sum();
+        }
+        PartTask p1 = new PartTask(matrix, start, (start + stop) / 2);
+        PartTask p2 = new PartTask(matrix, (start + stop) / 2, stop);
+        p1.fork();
+        p2.fork();
+        return p1.join() + p2.join();
+    }
+}
+```
+
+
 
 ### Особенности кода