src/Main.java - master - itokar98/HomeWorkConcurrentCollectionsTask1

src/Main.java
228 строк10 KB
Ilya Tokar
first commit
03 дек 2025, 01:29
03 дек 2025, 01:29f7a2f42
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {

    // Три блокирующие очереди для каждого анализирующего потока
    private static final BlockingQueue<String> queueA = new ArrayBlockingQueue<>(100);
    private static final BlockingQueue<String> queueB = new ArrayBlockingQueue<>(100);
    private static final BlockingQueue<String> queueC = new ArrayBlockingQueue<>(100);

    // Переменные для хранения результатов
    private static String maxAString = "";
    private static int maxACount = 0;

    private static String maxBString = "";
    private static int maxBCount = 0;

    private static String maxCString = "";
    private static int maxCCount = 0;

    // Счетчик сгенерированных текстов
    private static final AtomicInteger generatedCount = new AtomicInteger(0);
    private static final int TOTAL_TEXTS = 10_000;
    private static final int TEXT_LENGTH = 100_000;

    public static void main(String[] args) throws InterruptedException {
        System.out.println("Запуск анализа текстов...");

        // Создаем ExecutorService для управления потоками
        ExecutorService executor = Executors.newFixedThreadPool(4);

        // Запускаем поток-генератор текстов
        executor.submit(() -> {
            try {
                generateTexts();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // Запускаем три потока-анализатора
        executor.submit(() -> analyzeTexts('a', queueA, "A"));
        executor.submit(() -> analyzeTexts('b', queueB, "B"));
        executor.submit(() -> analyzeTexts('c', queueC, "C"));

        // Ждем завершения всех задач
        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        // Выводим результаты
        printResults();
    }

    /**
     * Генератор текстов
     * Генерирует тексты и помещает их в три очереди
     */
    private static void generateTexts() throws InterruptedException {
        Random random = new Random();

        for (int i = 0; i < TOTAL_TEXTS; i++) {
            // Генерируем текст
            String text = generateText("abc", TEXT_LENGTH);

            // Помещаем текст во все три очереди
            // (блокируемся, если очередь заполнена)
            queueA.put(text);
            queueB.put(text);
            queueC.put(text);

            // Увеличиваем счетчик сгенерированных текстов
            int count = generatedCount.incrementAndGet();

            // Выводим прогресс каждые 1000 текстов
            if (count % 1000 == 0) {
                System.out.println("Сгенерировано текстов: " + count + "/" + TOTAL_TEXTS);
            }
        }

        // Помещаем сигналы об окончании в очереди
        queueA.put("END");
        queueB.put("END");
        queueC.put("END");

        System.out.println("Генерация текстов завершена!");
    }

    /**
     * Метод для генерации текста (предоставлен в задании)
     */
    public static String generateText(String letters, int length) {
        Random random = new Random();
        StringBuilder text = new StringBuilder();
        for (int i = 0; i < length; i++) {
            text.append(letters.charAt(random.nextInt(letters.length())));
        }
        return text.toString();
    }

    /**
     * Анализатор текстов для конкретного символа
     * @param symbol символ для анализа ('a', 'b' или 'c')
     * @param queue очередь для обработки
     * @param threadName имя потока для отладки
     */
    private static void analyzeTexts(char symbol, BlockingQueue<String> queue, String threadName) {
        System.out.println("Поток " + threadName + " начал анализ...");

        int processedCount = 0;

        try {
            while (true) {
                // Получаем текст из очереди (блокируемся, если очередь пуста)
                String text = queue.take();

                // Проверяем сигнал об окончании
                if (text.equals("END")) {
                    break;
                }

                // Подсчитываем количество указанного символа в тексте
                int count = countSymbol(text, symbol);

                // Обновляем максимальное значение для текущего символа
                updateMax(text, count, symbol);

                processedCount++;

                // Выводим прогресс каждые 1000 текстов
                if (processedCount % 1000 == 0) {
                    System.out.println("Поток " + threadName +
                            " обработал текстов: " + processedCount);
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        System.out.println("Поток " + threadName +
                " завершил анализ. Обработано текстов: " + processedCount);
    }

    /**
     * Подсчет количества указанного символа в тексте
     */
    private static int countSymbol(String text, char symbol) {
        int count = 0;
        for (int i = 0; i < text.length(); i++) {
            if (text.charAt(i) == symbol) {
                count++;
            }
        }
        return count;
    }

    /**
     * Обновление максимального значения для символа
     */
    private static synchronized void updateMax(String text, int count, char symbol) {
        switch (symbol) {
            case 'a':
                if (count > maxACount) {
                    maxACount = count;
                    maxAString = text;
                }
                break;
            case 'b':
                if (count > maxBCount) {
                    maxBCount = count;
                    maxBString = text;
                }
                break;
            case 'c':
                if (count > maxCCount) {
                    maxCCount = count;
                    maxCString = text;
                }
                break;
        }
    }

    /**
     * Вывод результатов анализа
     */
    private static void printResults() {
        System.out.println("\n=== РЕЗУЛЬТАТЫ АНАЛИЗА ===");
        System.out.println("Всего сгенерировано текстов: " + generatedCount.get());
        System.out.println("Длина каждого текста: " + TEXT_LENGTH + " символов");
        System.out.println("Общий объем данных: " +
                (TOTAL_TEXTS * TEXT_LENGTH / 1_000_000.0) + " млн символов");

        System.out.println("\n--- Текст с максимальным количеством 'a' ---");
        System.out.println("Количество 'a': " + maxACount);
        System.out.println("Процент 'a': " +
                (maxACount * 100.0 / TEXT_LENGTH) + "%");
        System.out.println("Первые 100 символов текста: " +
                maxAString.substring(0, Math.min(100, maxAString.length())) + "...");

        System.out.println("\n--- Текст с максимальным количеством 'b' ---");
        System.out.println("Количество 'b': " + maxBCount);
        System.out.println("Процент 'b': " +
                (maxBCount * 100.0 / TEXT_LENGTH) + "%");
        System.out.println("Первые 100 символов текста: " +
                maxBString.substring(0, Math.min(100, maxBString.length())) + "...");

        System.out.println("\n--- Текст с максимальным количеством 'c' ---");
        System.out.println("Количество 'c': " + maxCCount);
        System.out.println("Процент 'c': " +
                (maxCCount * 100.0 / TEXT_LENGTH) + "%");
        System.out.println("Первые 100 символов текста: " +
                maxCString.substring(0, Math.min(100, maxCString.length())) + "...");

        // Статистика по всем символам
        System.out.println("\n--- ОБЩАЯ СТАТИСТИКА ---");
        System.out.println("Максимальное количество символов 'a' в одном тексте: " + maxACount);
        System.out.println("Максимальное количество символов 'b' в одном тексте: " + maxBCount);
        System.out.println("Максимальное количество символов 'c' в одном тексте: " + maxCCount);

        int totalMax = maxACount + maxBCount + maxCCount;
        System.out.println("Сумма максимальных значений: " + totalMax +
                " (теоретический максимум: " + TEXT_LENGTH + ")");
    }
}