HW1: implemented parallel multiplication matrixA*matrixB

afomin-basejava · afomin-basejava · commit ebbfbe87e127 · 2023-02-22T12:28:47.000+03:00
diff --git a/src/main/java/ru/javaops/masterjava/matrix/MainMatrix.java b/src/main/java/ru/javaops/masterjava/matrix/MainMatrix.java
@@ -4,15 +4,16 @@
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 
+import static ru.javaops.masterjava.matrix.MatrixUtil.MATRIX_SIZE;
+import static ru.javaops.masterjava.matrix.MatrixUtil.THREAD_NUMBER;
+
 /**
  * gkislin
  * 03.07.2016
  */
 public class MainMatrix {
-    private static final int MATRIX_SIZE = 1000;
-    private static final int THREAD_NUMBER = 10;
 
-    private final static ExecutorService executor = Executors.newFixedThreadPool(MainMatrix.THREAD_NUMBER);
+    private final static ExecutorService executor = Executors.newFixedThreadPool(THREAD_NUMBER);
 
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         final int[][] matrixA = MatrixUtil.create(MATRIX_SIZE);
@@ -47,6 +48,6 @@ public static void main(String[] args) throws ExecutionException, InterruptedExc
     }
 
     private static void out(String format, double ms) {
-        System.out.println(String.format(format, ms));
+        System.out.printf((format) + "%n", ms);
     }
 }
diff --git a/src/main/java/ru/javaops/masterjava/matrix/MatrixUtil.java b/src/main/java/ru/javaops/masterjava/matrix/MatrixUtil.java
@@ -1,20 +1,32 @@
 package ru.javaops.masterjava.matrix;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Random;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.ThreadPoolExecutor;
 
 /**
  * gkislin
  * 03.07.2016
  */
 public class MatrixUtil {
+    static final int MATRIX_SIZE = 1000;
+    static final int THREAD_NUMBER = 10;
 
-    // TODO implement parallel multiplication matrixA*matrixB
+    // T_O_D_O implement parallel multiplication matrixA*matrixB
     public static int[][] concurrentMultiply(int[][] matrixA, int[][] matrixB, ExecutorService executor) throws InterruptedException, ExecutionException {
         final int matrixSize = matrixA.length;
         final int[][] matrixC = new int[matrixSize][matrixSize];
-
+//        List<CallableTask> tasks = new ArrayList<>();
+//        executor.invokeAll(tasks);
+        for (int i = 0; i < MATRIX_SIZE; i++) {
+            for (int j = 0; j < MATRIX_SIZE; j++) {
+                executor.submit(new Task(matrixA, matrixB, matrixC, i, j));
+            }
+        }
+        while (((ThreadPoolExecutor) executor).getQueue().size() > 0) ;
         return matrixC;
     }
 
@@ -58,4 +70,29 @@ public static boolean compare(int[][] matrixA, int[][] matrixB) {
         }
         return true;
     }
+
+    static class Task implements Runnable {
+        private final int[][] matrixA;
+        private final int[][] matrixB;
+        private final int[][] matrixC;
+        private final int i;
+        private final int j;
+
+        public Task(int[][] matrixA, int[][] matrixB, int[][] matrixC, int i, int j) {
+            this.matrixA = matrixA;
+            this.matrixB = matrixB;
+            this.matrixC = matrixC;
+            this.i = i;
+            this.j = j;
+        }
+
+        @Override
+        public void run() {
+            int sum = 0;
+            for (int k = 0; k < matrixA.length; k++) {
+                sum += matrixA[i][k] * matrixB[k][j];
+            }
+            matrixC[i][j] = sum;
+        }
+    }
 }
