Main.java - master - ProjectEroxa/MultiThreading_Concurrent_ArrayBlockingQueue

Main.java
189 строк8 KB
Евгений Ерошкин
update Main.java
10 сен 2025, 10:59
10 сен 2025, 10:59a8300fb
import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static AtomicInteger counter3 = new AtomicInteger(0);
    static AtomicInteger counter4 = new AtomicInteger(0);
    static AtomicInteger counter5 = new AtomicInteger(0);

    static BlockingQueue<String> textsQ1 = new ArrayBlockingQueue<>(100);
    static BlockingQueue<String> textsQ2 = new ArrayBlockingQueue<>(100);
    static BlockingQueue<String> textsQ3 = new ArrayBlockingQueue<>(100);

    public static void main(String[] args) {
        Random random = new Random();
        String[] texts = new String[100_000];
        for (int i = 0; i < texts.length; i++) {
            texts[i] = generateText("abc", 3 + random.nextInt(3));
        }
        //Пользователь может выбрать из них только те, которые соответствуют критериям «красивого» никнейма, а именно:
//сгенерированное слово является палиндромом, т. е. читается одинаково как слева направо, так и справа налево, например, abba;
//сгенерированное слово состоит из одной и той же буквы, например, aaa;
//буквы в слове идут по возрастанию: сначала все a (при наличии), затем все b (при наличии), затем все c и т. д. Например, aaccc.
        //и все это разделить на длины слов
        new Thread(() -> {
            //выбираю все слова не длиннее 3 символов в массиве texts
            for (String text : texts) {
                if (text.length() == 3) {
                    if (isPalindrom(text) || similarChars(text) || increasingChar(text)) {
                        // и увеличиваю счетчик
                        counter3.getAndIncrement();
                    }
                }
            }
        }).start();

        new Thread(() -> {
            for (String text : texts) {
                if (text.length() == 4) {
                    if (isPalindrom(text) || similarChars(text) || increasingChar(text)) {
                        // и увеличиваю счетчик
                        counter4.getAndIncrement();
                    }
                }
            }

        }).start();

        new Thread(() -> {
            for (String text : texts) {
                if (text.length() == 5) {
                    if (isPalindrom(text) || similarChars(text) || increasingChar(text)) {
                        // и увеличиваю счетчик
                        counter5.getAndIncrement();
                    }
                }
            }

        }).start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                try {
                    textsQ1.put(generateText("abc", 10_000));
                    textsQ2.put(generateText("abc", 10_000));
                    textsQ3.put(generateText("abc", 10_000));
                } catch (InterruptedException e) {
                    return;
                }
            }
        }).start();

        new Thread(() -> {
            long maxA = 0;
            for (int i = 0; i < 100; i++) {
                String text = null;
                try {
                    text = textsQ1.take();
                } catch (InterruptedException e) {
                    return;
                }
                long countA = text.chars().filter(a -> a == 'a').count();
                maxA = Math.max(maxA, countA);
            }
            System.out.println("Самое большое количество а: " + maxA);
        }).start();

        new Thread(() -> {
            long maxB = 0;
            for (int i = 0; i < 100; i++) {
                String text = null;
                try {
                    text = textsQ2.take();
                } catch (InterruptedException e) {
                    return;
                }
                long countB = text.chars().filter(b -> b == 'b').count();
                maxB = Math.max(maxB, countB);
            }
            System.out.println("Самое большое количество b: " + maxB);
        }).start();

        new Thread(() -> {
            long maxC = 0;
            for (int i = 0; i < 100; i++) {
                String text = null;
                try {
                    text = textsQ3.take();
                } catch (InterruptedException e) {
                    return;
                }
                long countC = text.chars().filter(c -> c == 'c').count();
                maxC = Math.max(maxC, countC);
            }
            System.out.println("Самое большое количество c: " + maxC);
        }).start();

        System.out.println("Красивых слов с длиной 3: " + counter3.get());
        System.out.println("Красивых слов с длиной 4: " + counter4.get());
        System.out.println("Красивых слов с длиной 5: " + counter5.get());
    }

    //метод генерирует слова
    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();
    }

    //метод проверяет на полиндром
    public static boolean isPalindrom(String string) {
        int count = string.length();
        int countIf = 0;
        for (int i = 0; i < string.length(); i++) {
            char start = string.charAt(i);
            char end = string.charAt(string.length() - i - 1);
            if (start == end) {
                countIf++;
            }
            if (countIf == count) {
                return true;
            }
        }
        return false;
    }

    //метод проверят что слово состоит из одинаковых букв
    public static boolean similarChars(String string) {
        int count = string.length();
        int countIf = 0;
        for (int i = 0; i < string.length(); i++) {
            char start = string.charAt(0);
            char next = string.charAt(i);
            if (start == next) {
                countIf++;
            }
            if (countIf == count) {
                return true;
            }
        }
        return false;
    }

    //метод проверяет, что буквы в слове идут по возрастанию: сначала все a (при наличии),
// затем все b (при наличии), затем все c и т. д.
    public static boolean increasingChar(String string) {
        for (int i = 1; i < string.length(); i++) {
            char currentChar = string.charAt(i);
            char prevChar = string.charAt(i - 1);

            // Если текущий символ должен быть "меньше" предыдущего - нарушение порядка
            if (currentChar < prevChar) {
                return false;
            }
            //Убираю слова с одинаковыми буквами
            if (similarChars(string)) {
                return false;
            }
            // Если текущий символ такой же как предыдущий - это допустимо (буквы идут подряд)
            // Если текущий символ больше предыдущего - это правильный переход к следующей букве
        }
        return true;
    }

}