🖥 Освежите свои знания о CompletableFuture

Задачи, которые требуют асинхронного выполнения, могут стать настоящей головной болью, если использовать устаревшие методы. Однако, есть мощный инструмент — CompletableFuture, который упрощает работу с параллельными вычислениями, обеспечивая гибкость, читаемость и исключение возможных ошибок в многозадачности. Статья содержит интересный пример использования этого инструмента. В ней описана реализация веб-сканера, который будет по ссылкам искать новости, посвященные хакингу.

🔗 Читать статью

ℹ️ Ключевое слово volatile

volatile — это ключевое слово, которое используется для указания компилятору и JVM, что значение переменной может изменяться из нескольких потоков. Это гарантирует, что чтение и запись переменной будут происходить непосредственно в основной памяти, а не в кэше процессора, что позволяет избежать различных проблем синхронизации между потоками.

▪️ Синхронизация чтения и записи: Переменная, помеченная как volatile, всегда будет читать свое значение из основной памяти, а не из локальных кешей потоков.
▪️ Обеспечение видимости: Когда один поток изменяет значение переменной, все другие потоки немедленно видят эти изменения.
▪️ Отсутствие блокировок: В отличие от использования synchronized, volatile не блокирует выполнение потоков, что делает его более легковесным способом синхронизации.

Когда использовать volatile?
- Когда переменная должна быть доступна для записи и чтения несколькими потоками, но нет необходимости в сложной синхронизации (например, для флагов, флагов завершения, индикаторов состояний).
- В случаях, когда нужно просто гарантировать видимость изменений, но не требуется атомарность или операции с несколькими шагами (для этих случаев лучше использовать synchronized или java.util.concurrent).

Пример:

public class VolatileExample {
    private static volatile boolean flag = false; 

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            try {
                Thread.sleep(1000); // эмулируем задержку
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            flag = true; 
            System.out.println("Flag set to true");
        });

        Thread reader = new Thread(() -> {
            while (!flag) { 
            }
            System.out.println("Flag is now true");
        });

        writer.start();
        reader.start();

        writer.join();
        reader.join();
    }
}

ℹ️ Что такое "Проблема бриллианта" (Diamond Problem)?

Проблема бриллианта (или Diamond Problem) — это ситуация, которая возникает в языках программирования с поддержкой множественного наследования. Она заключается в том, что если один класс наследует два или более класса, которые имеют общий предок, то возникает неопределенность, с какого родительского класса должны быть унаследованы члены (методы или поля).

В Java множественное наследование классов не поддерживается, но проблема все равно может возникнуть при использовании интерфейсов.

interface A {
    void method();
}

interface B extends A {
    @Override
    default void method() {
        System.out.println("Method from B");
    }
}

interface C extends A {
    @Override
    default void method() {
        System.out.println("Method from C");
    }
}

class D implements B, C { }

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.method();  // Какая версия метода будет вызвана?
    }
}

📌 В чем суть проблемы?

Когда класс D реализует оба интерфейса B и C, которые оба предоставляют дефолтные реализации метода method(), возникает неопределенность — какую версию метода должен использовать класс D? При компиляции будет выброшен error: class D inherits unrelated defaults for method() from types B and C.

Это решается с помощью явного переопределения метода в классе D, что позволяет избежать конфликтов.

class D implements B, C {
    @Override
    public void method() {
        B.super.method();
        // или можно использовать C.super.method(), если хотите вызвать метод из C
    }
}

🔼 Roadmap от джуна до сеньора

🔹 Инструменты для работы в команде: Освойте Jira, Confluence, Slack, MS Teams, Zoom и другие.
🔹 Языки программирования: Углубитесь в 1-2 языка, например, Python, С#.
🔹 Разработка API: Изучите REST, GraphQL, gRPC.
🔹 Серверы и хостинг: Ознакомьтесь с AWS, Azure, GCP, Kubernetes.
🔹 Аутентификация и тестирование: Освойте JWT, OAuth2, TDD и нагрузочное тестирование.
🔹 Базы данных: Работайте с SQL (Postgres, MySQL) и NoSQL (MongoDB).
🔹 CI/CD: Изучите GitHub Actions, Jenkins.
🔹 Алгоритмы: Разберитесь в Big O, деревьях, графах.
🔹 Системный дизайн: Погрузитесь в кэширование, микросервисы, балансировку нагрузки.
🔹 Паттерны проектирования: Изучите DI, фабрику и другие паттерны.
🔹 AI-инструменты: Научитесь использовать GitHub Copilot, ChatGPT.

💬 Какие пункты вы бы ещё добавили?

📊 Как работает CopyOnWriteArrayList под капотом?

CopyOnWriteArrayList — это потокобезопасная реализация списка, оптимизированная для сценариев с частым чтением и редкими изменениями. Когда происходит изменение в CopyOnWriteArrayList, создаётся новая копия базового массива, в которую вносятся изменения. Таким образом, чтение и запись изолированы: до завершения модификации читающие потоки получают доступ к старому массиву, а запись завершает свою работу, не блокируя других потоков.

💡 Основные механизмы:

🔹 До завершения операции модификации все читающие потоки продолжают работать с текущей неизменяемой версией массива.
🔹 При вызове методов, изменяющих список (например, add, remove), создаётся новый массив на основе старого. Изменения применяются именно к новому массиву.
🔹 После завершения модификации ссылка на массив обновляется на новую версию. Теперь все новые операции чтения будут работать с обновлённой версией.

⚠️ Особенности:

▪️ Высокие накладные расходы на запись из-за создания копий.
▪️ Подходит для случаев, где чтение доминирует над изменением.
▪️ Не рекомендуется для сценариев с частыми обновлениями из-за увеличения потребления памяти.

CopyOnWriteArrayList идеально подходит для кешей, обработчиков событий и других структур данных, где важна стабильность чтения при редких изменениях.

Документация

🕯 Паттерн Посетитель (Visitor)

Visitor — это поведенческий паттерн, который позволяет добавлять новые операции к объектам без изменения их классов. Он выделяет операции в отдельный объект, называемый "посетитель", что позволяет избежать дублирования кода и поддерживать open/closed архитектуру.

Использование:

🔹 Когда нужно добавлять новые операции к иерархии классов без изменения их структуры.
🔹 Когда объектам требуется обработка, зависящая от их типов, но нежелательно добавлять логику внутрь самих классов.

Преимущества:

1️⃣ Упрощает добавление новых операций.
2️⃣ Логика работы концентрируется в одном месте, а не размазывается по классам.
3️⃣ Сохраняется открытость к изменениям операций и закрытость классов к модификациям.

Недостатки:

1️⃣ Увеличивает количество классов.
2️⃣ Добавление нового типа в иерархию требует обновления всех существующих посетителей.
3️⃣ Работает лучше всего с фиксированной иерархией.

📌 Visitor идеально подходит для сценариев, где требуется частое добавление новых операций при сохранении стабильности классов.

🐍☕️ Тайные питонисты среди нас?

Не секрет, что среди Java-разработчиков скрываются те, кто втайне любит Python. Кто украдкой пишет скрипты на Python для автоматизации или просто мечтает о жизни без фигурных скобок.

📌 Пройдите тест и проверьте, не живет ли внутри вас тайный питонист.

P.S. Не волнуйтесь, никто не будет осуждать, если вам вдруг понравится 🙂

🔗 Динамическое и статическое связывание

Связывание (binding) определяет, какой метод будет вызван во время выполнения программы. Понимание различий между динамическим и статическим связыванием важно для эффективного использования полиморфизма и оптимизации производительности приложения.

🔵 Статическое связывание (Static Binding)

Статическое связывание происходит на этапе компиляции. Компилятор определяет, какой метод или переменная будут использоваться, основываясь на типе ссылки.

▪️ Когда используется?

- Статические методы (static)
- Частные методы (private)
- Методы в финальных классах (final)
- Перегруженные методы (method overloading)

▪️ Пример:

class A {
    static void display() { System.out.println("Static A"); }
}

class B extends A {
    static void display() { System.out.println("Static B"); }
}

public class Main {
    public static void main(String[] args) {
        A obj = new B();
        obj.display(); // Выведет: Static A
    }
}

display() — статический метод. Вызов определяется типом ссылки A, поэтому вызывается A.display().

🔵 Динамическое связывание (Dynamic Binding)

Динамическое связывание происходит во время выполнения (runtime). JVM определяет, какой метод вызвать, основываясь на фактическом типе объекта.

▪️ Когда используется?

- Переопределенные методы (method overriding)
- Нестатические методы (instance methods)

▪️ Пример:

class A {
    void display() { System.out.println("Dynamic A"); }
}

class B extends A {
    @Override
    void display() { System.out.println("Dynamic B"); }
}

public class Main {
    public static void main(String[] args) {
        A obj = new B();
        obj.display(); // Выведет: Dynamic B
    }
}

display() — нестатический метод. Вызов определяется фактическим типом объекта B, поэтому вызывается B.display().

🔵 Практические применения

▪️ Статическое связывание:

- Утилитные классы: Методы Math.max(), Collections.sort() и другие статические методы часто используют статическое связывание для быстрого доступа.
- Безопасность: Приватные методы не могут быть переопределены, что предотвращает изменение внутренней логики класса.

▪️ Динамическое связывание:

- Полиморфизм: Позволяет создавать гибкие и расширяемые системы. Например, использование интерфейсов и абстрактных классов для определения контрактов.
- Фреймворки и библиотеки: Многие фреймворки (например, Spring) используют динамическое связывание для внедрения зависимостей и аспектно-ориентированного программирования (AOP).

❓ Как относитесь к функциональному стилю в Java?

❤️ Отлично, Java стала мощнее и лаконичнее.
🤔 Использую только там, где это действительно оправдано.
🌚 Функциональщина не для меня, только классическое ООП.

💬 Делитесь опытом и мнением в комментариях