hw9, Daria Suvorova

src/main/java/edu/hw9/Task1/MetricStats.java

@@ -0,0 +1,5 @@
+package edu.hw9.Task1;
+
+
+public record MetricStats(String name, double sum, double average, double max, double min) {
+}

src/main/java/edu/hw9/Task1/StatsCollector.java

@@ -0,0 +1,40 @@
+package edu.hw9.Task1;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class StatsCollector {
+    ConcurrentHashMap<String, double[]> metricsData;
+
+    public StatsCollector() {
+        metricsData = new ConcurrentHashMap<>();
+
+    }
+
+    public void push(String name, double[] data) {
+        metricsData.put(name, data);
+    }
+
+    public Map<String, MetricStats> stats() {
+        Map<String, MetricStats> answer = new HashMap<>();
+
+        for (var name : metricsData.keySet()) {
+
+            double[] metric = metricsData.get(name);
+
+            double sum = Arrays.stream(metric).sum();
+
+            double average = sum / metric.length;
+
+            double max = Arrays.stream(metric).max().getAsDouble();
+
+            double min = Arrays.stream(metric).min().getAsDouble();
+
+            answer.put(name, new MetricStats(name, sum, average, max, min));
+        }
+        return answer;
+    }
+
+}

src/main/java/edu/hw9/Task3/DfsConcurrent.java

@@ -0,0 +1,56 @@
+package edu.hw9.Task3;
+
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class DfsConcurrent {
+
+    private DfsConcurrent() {}
+
+    static public AtomicBoolean[] dfs(int start, Map<Integer, int[]> graph, int threadsNumber) {
+        AtomicBoolean[] isVisited = new AtomicBoolean[graph.size()];
+        for (int i = 0; i < graph.size(); i++) {
+            isVisited[i] = new AtomicBoolean(false);
+        }
+
+        ExecutorService executorService = Executors.newFixedThreadPool(threadsNumber);
+
+        try {
+
+            return dfsRecursive(start, isVisited, graph, executorService);
+        } finally {
+            executorService.shutdown();
+        }
+    }
+
+    static private AtomicBoolean[] dfsRecursive(
+        int current,
+        AtomicBoolean[] isVisited,
+        Map<Integer, int[]> graph,
+        ExecutorService executorService
+    ) {
+        isVisited[current].set(true);
+
+        ArrayList<Future<?>> result = new ArrayList<>();
+
+        for (int dest : graph.get(current)) {
+
+            result.add(executorService.submit(() -> {
+                if (!isVisited[dest].get()) {
+                    dfsRecursive(dest, isVisited, graph, executorService);
+                }
+            }));
+
+        }
+
+        while (!result.stream().allMatch(Future::isDone)) {
+        }
+
+        return isVisited;
+    }
+
+}

src/test/java/edu/hw9/Task1Test.java

@@ -0,0 +1,63 @@
+package edu.hw9;
+
+import edu.hw9.Task1.StatsCollector;
+import edu.hw9.Task1.MetricStats;
+import org.junit.jupiter.api.Test;
+import java.util.Map;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class Task1Test {
+
+    @Test
+    void statsCollectorTest() {
+
+        StatsCollector collector = new StatsCollector();
+
+        Thread thread1 = new Thread(() -> {
+            collector.push("metric1", new double[] {0, 0.5, 1, 1.5});
+        });
+
+        Thread thread2 = new Thread(() -> {
+            collector.push("metric2", new double[] {1, 2, 3, 4});
+        });
+        Thread thread3 = new Thread(() -> {
+            collector.push("metric3", new double[] {-5, -4, -3, -2});
+        });
+        Thread thread4 = new Thread(() -> {
+            collector.push("metric4", new double[] {0, 0, 0, 0});
+        });
+        Thread thread5 = new Thread(() -> {
+            collector.push("metric5", new double[] {0.2, 0.3, 0.4, 0.5});
+        });
+
+        Map<String, MetricStats> expected = Map.of("metric1", new MetricStats("metric1", 3, 0.75, 1.5, 0),
+            "metric2", new MetricStats("metric2", 10, 2.5, 4, 1),
+            "metric3", new MetricStats("metric3", -14, -3.5, -2, -5),
+            "metric4", new MetricStats("metric4", 0, 0, 0, 0),
+            "metric5", new MetricStats("metric5", 1.4, 0.35, 0.5, 0.2)
+        );
+
+        thread1.start();
+        thread2.start();
+        thread3.start();
+        thread4.start();
+        thread5.start();
+
+        try {
+            thread1.join();
+            thread2.join();
+            thread3.join();
+            thread4.join();
+            thread5.join();
+
+
+            assertEquals(expected.entrySet(), collector.stats().entrySet());
+
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+
+    }
+
+}

src/test/java/edu/hw9/Task2Test.java

@@ -0,0 +1,4 @@
+package edu.hw9;
+
+public class Task2Test {
+}

src/test/java/edu/hw9/Task3Test.java

@@ -0,0 +1,60 @@
+package edu.hw9;
+
+import org.junit.jupiter.api.Test;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicBoolean;
+import static edu.hw9.Task3.DfsConcurrent.dfs;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Task3Test {
+
+
+
+    void atomicArraysEquals(AtomicBoolean[] expected, AtomicBoolean[] actual) {
+        assertEquals(expected.length, actual.length);
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals(expected[i].get(), actual[i].get());
+        }
+    }
+
+    @Test
+    void dfsConcurrentTest1() {
+        Map<Integer, int[]> graph = Map.of(0, new int[] {1, 2},
+            1, new int[] {2, 3},
+            2, new int[] {},
+            3, new int[] {},
+            4, new int[] {0}
+        );
+
+        AtomicBoolean[] actual = dfs(0, graph, 4);
+
+        AtomicBoolean[] expected = new AtomicBoolean[] {new AtomicBoolean(true),
+            new AtomicBoolean(true),
+            new AtomicBoolean(true),
+            new AtomicBoolean(true),
+            new AtomicBoolean(false)};
+
+        atomicArraysEquals(expected, actual);
+    }
+    @Test
+    void dfsConcurrentTest2() {
+        Map<Integer, int[]> graph = Map.of(0, new int[] {},
+            1, new int[] {},
+            2, new int[] {},
+            3, new int[] {},
+            4, new int[] {}
+        );
+
+        AtomicBoolean[] actual = dfs(3, graph, 4);
+
+        AtomicBoolean[] expected = new AtomicBoolean[] {new AtomicBoolean(false),
+            new AtomicBoolean(false),
+            new AtomicBoolean(false),
+            new AtomicBoolean(true),
+            new AtomicBoolean(false)};
+
+        atomicArraysEquals(expected, actual);
+    }
+
+
+}