src/Main.java - master - itokar98/HomeWorkMultithreadingTask3

src/Main.java
140 строк6 KB
Ilya Tokar
first_commit
29 ноя 2025, 12:48
29 ноя 2025, 12:485166d9e
import java.util.concurrent.*;
import java.util.*;

public class Main {

    // Класс для многопоточного вычисления суммы с ForkJoin
    static class ArraySumTask extends RecursiveTask<Long> {
        private static final int THRESHOLD = 10_000; // Порог для последовательного вычисления
        private final int[] array;
        private final int start;
        private final int end;

        public ArraySumTask(int[] array, int start, int end) {
            this.array = array;
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {
            int length = end - start;

            // Если массив небольшой, вычисляем последовательно
            if (length <= THRESHOLD) {
                return computeDirectly();
            }

            // Делим задачу на две подзадачи
            int middle = start + length / 2;
            ArraySumTask leftTask = new ArraySumTask(array, start, middle);
            ArraySumTask rightTask = new ArraySumTask(array, middle, end);

            // Асинхронно запускаем левую задачу
            leftTask.fork();

            // Вычисляем правую задачу и ждем левую
            long rightResult = rightTask.compute();
            long leftResult = leftTask.join();

            return leftResult + rightResult;
        }

        private long computeDirectly() {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += array[i];
            }
            return sum;
        }
    }

    // Генерация массива случайных чисел
    public static int[] generateArray(int size) {
        Random random = new Random();
        int[] array = new int[size];
        for (int i = 0; i < size; i++) {
            array[i] = random.nextInt(1000); // Числа от 0 до 999
        }
        return array;
    }

    // Однопоточное вычисление суммы
    public static long calculateSumSingleThread(int[] array) {
        long sum = 0;
        for (int value : array) {
            sum += value;
        }
        return sum;
    }

    // Однопоточное вычисление среднего
    public static double calculateAverageSingleThread(int[] array) {
        long sum = calculateSumSingleThread(array);
        return (double) sum / array.length;
    }

    // Многопоточное вычисление суммы с ForkJoinPool
    public static long calculateSumMultiThread(int[] array) {
        ForkJoinPool pool = new ForkJoinPool();
        try {
            ArraySumTask task = new ArraySumTask(array, 0, array.length);
            return pool.invoke(task);
        } finally {
            pool.shutdown();
        }
    }

    // Многопоточное вычисление среднего
    public static double calculateAverageMultiThread(int[] array) {
        long sum = calculateSumMultiThread(array);
        return (double) sum / array.length;
    }

    public static void main(String[] args) {
        // Тестируем на разных размерах массивов
        int[] sizes = {10_000, 100_000, 1_000_000, 10_000_000, 100_000_000};

        for (int size : sizes) {
            System.out.println("\n" + "=".repeat(60));
            System.out.println("РАЗМЕР МАССИВА: " + String.format("%,d", size) + " элементов");
            System.out.println("=".repeat(60));

            // Генерируем массив
            System.out.println("Генерация массива...");
            long startTime = System.currentTimeMillis();
            int[] array = generateArray(size);
            long generationTime = System.currentTimeMillis() - startTime;
            System.out.printf("Массив сгенерирован за: %,d мс\n", generationTime);

            // Однопоточное вычисление
            System.out.println("\n--- ОДНОПОТОЧНОЕ ВЫЧИСЛЕНИЕ ---");
            startTime = System.currentTimeMillis();
            long singleSum = calculateSumSingleThread(array);
            double singleAverage = calculateAverageSingleThread(array);
            long singleTime = System.currentTimeMillis() - startTime;

            System.out.printf("Сумма: %,d\n", singleSum);
            System.out.printf("Среднее: %.2f\n", singleAverage);
            System.out.printf("Время: %,d мс\n", singleTime);

            // Многопоточное вычисление
            System.out.println("\n--- МНОГОПОТОЧНОЕ ВЫЧИСЛЕНИЕ ---");
            startTime = System.currentTimeMillis();
            long multiSum = calculateSumMultiThread(array);
            double multiAverage = calculateAverageMultiThread(array);
            long multiTime = System.currentTimeMillis() - startTime;

            System.out.printf("Сумма: %,d\n", multiSum);
            System.out.printf("Среднее: %.2f\n", multiAverage);
            System.out.printf("Время: %,d мс\n", multiTime);

            // Сравнение
            System.out.println("\n--- СРАВНЕНИЕ ---");
            System.out.printf("Результаты совпадают: %b\n", singleSum == multiSum);
            System.out.printf("Ускорение: %.2f раз\n", (double) singleTime / multiTime);
            System.out.printf("Эффективность многопоточности: %s\n",
                    multiTime < singleTime ? "ДА" : "НЕТ");
        }
    }
}