Jetbulb | Как стать востребованным Java разработчиком

🤚 Как насчет того, чтобы пройти путь от новичка до разработчика в Новом году?

И освоить один из самых востребованных языков программирования

Набираем новый поток обучения на курс "Java Enterprise: От новичка до разработчика"👇🏻

За 6 месяцев вы :
— Освоите все необходимые навыки для старта в профессии;
— Научитесь свободно программировать на популярном языке Java;
— Получите полноценный роудмеп для дальнейшего развития.

Курс подойдет, если вы:
- Новичок в программировании
- Изучаете Java самостоятельно
- Разработчик на другом ЯП

Если у вас есть сомнения, пишите нашему менеджеру, который подскажет насколько для вас актуален курс на данный момент

Часть технологий, которые вы освоите:
- Git
- Java Core
- JUnit
- Maven и Gradle
- SQL
- JPA и Hibernate
- Spring Core
- Spring Data Access
- Spring Web
- Spring Webflux
- Spring Security
- Docker

А так же дополните свое портфолио 5 проектами с использованием микросервисов.

Посмотреть полную программу и список технологий можно 👉🏻 тут

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

Все обучение проходит в мини-группах до 30 человек👇🏻

1. Посещаете онлайн-занятие
2 раза в неделю по 1,5 часа. Преподаватель объясняет материал, отвечает на вопросы и дает обратную связь каждому. Занятие всегда можно пересмотреть в записи.

2. Выполняете домашнее задание
В удобное для вас время и сдаете задание на платформе

3. Получаете персональную обратную связь
Вашу работу проверяет преподаватель, он же ментор на курсе. Никаких дополнительный кураторов и посредников.

_________________________

💰До нового года можно успеть забронировать место по старой стоимости, всего 100$ в месяц. Количество мест строго ограничено.

🌐 Изучить подробнее и оставить заявку можно на странице - iprody.com/courses

Если у вас остались вопросы или вы хотите уточнить информацию - смело пишите нашему менеджеру

❓Шаблон проектирования в Java. Lazy Singleton

Совсем недавно проходил квиз, который был посвящен шаблонам проектирования часто применяемым в Java, а именно популярнейший Singleton (Одиночка). Данный пост прольет свет на способы реализации данного шаблона проектирования, их преимущества и недостатки.

Singleton — шаблон проектирования, который ограничивает создание объектов класса одним экземпляром и предоставляет глобальную точку доступа к этому экземпляру. Lazy Singleton — это разновидность Singleton, в которой объект создается только тогда, когда он действительно нужен (ленивый подход).

▶️Преимущества Lazy Singleton
🔹Экономия ресурсов. Экземпляр создается только тогда, когда он реально необходим.
🔹Отложенная инициализация. Полезно в системах, где создание объекта ресурсоемко.
🔹Контроль над созданием объекта. Легко управлять временем инициализации.

▶️Реализация Lazy Singleton
Ленивая инициализация требует, чтобы объект создавался только при первом запросе. Рассмотрим разные способы реализации.

0️⃣Простейшая реализация (не потокобезопасная)

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // Закрытый конструктор для предотвращения создания экземпляров
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

🔹Плюсы. Простой и читаемый код.
🔹Минусы. Не подходит для многопоточной среды, так как возможны ситуации, когда несколько потоков одновременно создадут экземпляры.

1️⃣Потокобезопасная реализация с синхронизацией

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {
        // Закрытый конструктор
    }

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

🔹Плюсы. Подходит для многопоточной среды.
🔹Минусы. Низкая производительность из-за синхронизации метода, даже после создания экземпляра.

2️⃣Double-Checked Locking (двойная проверка)

public class LazySingleton {
    private static volatile LazySingleton instance;

    private LazySingleton() {
        // Закрытый конструктор
    }

    public static LazySingleton getInstance() {
        if (instance == null) {
            synchronized (LazySingleton.class) {
                if (instance == null) {
                    instance = new LazySingleton();
                }
            }
        }
        return instance;
    }
}

🔹Плюсы. Высокая производительность благодаря минимальной синхронизации.
🔹Минусы. Сложнее читается, требуется понимание ключевого слова volatile.

3️⃣Использование вложенного класса (Initialization-on-demand holder idiom)

public class LazySingleton {
    private LazySingleton() {
        // Закрытый конструктор
    }

    private static class Holder {
        private static final LazySingleton INSTANCE = new LazySingleton();
    }

    public static LazySingleton getInstance() {
        return Holder.INSTANCE;
    }
}

🔹Плюсы. Потокобезопасность без синхронизации, и ленивая инициализация за счет особенностей загрузки классов в Java.
🔹Минусы. Требует понимания особенностей работы классов в JVM.

Lazy Singleton отлично подходит для случаев, когда создание объекта требует больших ресурсов и используется нечасто. В случае многопоточной среды, где важно поддерживать данные в консистентной форме и не нарушать общие правилы работы с многопоточностью, рекомендуется применить варианты реализации: Double-Checked Locking или Holder Class. Они обеспечивают безопасность при балансе в производительности. Но как бы там ни был, выбор реализации все зависит от конкретных требований к производительности и архитектуры приложения.

⬇️ Какие шаблоны проектирования чаще всего приходится реализовывать тебе? Пиши о своем опыте в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент

🧑‍💻 Что такое Elasticsearch и где его применяют в реальной разработке

Привет, всем!
Макс вещает 😼

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

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

▶️Основные возможности Elasticsearch
🔹Полнотекстовый поиск. Позволяет искать по текстам и документам, включая возможности для поиска с учетом синонимов, с использованием подсветки, фильтров и автозаполнения.
🔹Анализ данных. Поддерживает сложные запросы для анализа данных в реальном времени, включая агрегации, что позволяет выполнять статистические и аналитические операции.
🔹Гибкость индексации. Elasticsearch позволяет эффективно индексировать документы разных типов и структур, что удобно для работы с разнородными данными.
🔹Масштабируемость. Elasticsearch — это распределенная система, которая может работать на множестве серверов, что позволяет масштабировать как объем хранимых данных, так и производительность.
🔹Поддержка JSON. Данные в Elasticsearch хранятся в формате JSON, что делает его удобным для работы с веб-приложениями и API-интеграции.

▶️Как работает Elasticsearch?
🔹Индексы и документы. Данные в Elasticsearch организуются в индексы (аналогично базам данных в традиционных системах), которые содержат документы — JSON-объекты с информацией. Каждый документ состоит из полей, представляющих структуру данных.
🔹Шарды и реплики. Индексы делятся на шарды для распределения нагрузки между узлами кластера. Для отказоустойчивости создаются реплики (копии) каждого шарда, чтобы данные оставались доступными в случае отказа какого-либо узла.
🔹Запросы и агрегации. Elasticsearch поддерживает сложные запросы и агрегации, которые позволяют анализировать и группировать данные для получения полезных аналитических данных.

▶️Так где же его применяют?
🔹Анализ логов и мониторинг. Вместе с Kibana (инструмент визуализации от Elastic), Elasticsearch часто используется для мониторинга приложений и анализа логов.
🔹Полнотекстовый поиск. Обеспечивает быстрое и релевантное полнотекстовое индексирование и поиск по текстовым данным.
🔹Аналитика и BI. Используется для анализа больших объемов данных в реальном времени с поддержкой сложных аналитических запросов.
🔹Рекомендательные системы. Elasticsearch может быстро обрабатывать запросы для рекомендаций товаров или контента.

▶️Преимущества
🔹Высокая производительность и масштабируемость.
🔹Возможность горизонтального масштабирования.
🔹Поддержка полнотекстового поиска и аналитики.

▶️Ограничения
🔹Сложность в освоении.
🔹Хранение данных в оперативной памяти может потребовать значительных ресурсов.
🔹Elasticsearch может быть сложным для использования в качестве основного хранилища данных.

▶️Заключение
Elasticsearch не является панацеей, но это действительно мощный инструмент для поиска и анализа данных, идеально подходящий для полнотекстового поиска и работы с большими объемами данных в реальном времени. Он широко применяется для мониторинга, поиска по тексту, и аналитики, особенно в системах, требующих быстрой обработки и анализа данных.

Если вашей системе необходимы именно эти возможности, то действительно стоит рассмотреть Elasticsearch. В противном случае, я бы поискал что-то подешевле и попроще.

🔗Полезные ссылки
Официальная документация Elasticsearch
Официальная документация Apache Lucene

Макс Добрынин
Software Engineer

⚡️Пара свободных мест в группах уровня Junior и Middle

Получите коммерческий опыт разработки на реальном проекте в Agile команде с ментором уровня Senior.

Практика позволяет повысить навыки разработки, освоить востребованный на рынке стек, почувствовать себя частью команды, получить недостающий опыт и реальный отзыв о проделанной работе.

Важно понимать, что это командная разработка реального проекта, а не просто курс с лекциями.

На проекте используется свежий стек технологий:
- Java (последние версии)
- Spring Boot
- Spring Framework (WebFlux, R2DBC, Security, др.)
- Slf4j, Logback, Distributed Logging
- JUnit, AssertJ, Mockito
- Maven, Gradle
- SQL, JPA, Hibernate
- Docker
- Kafka/RabbitMQ
- Microservices

Уже выпустили 13 команд и 83% ребят, которые успешно проходят стажировку на платформе iPrody - получают оффер в первый же месяц.

👉🏻 В этом видео можно посмотреть подробнее, как устроена стажировка внутри

Есть гарантия возврата денег в течение первых 14-ти дней с начала старта группы. Если за это время вы поймёте, что материалы или формат вам не подходят, просто напишите менеджеру, и мы вернем вам всю сумму обратно👌🏻

__________________

✅ Чтобы успеть забронировать место на проекте пишите менеджеру напрямую или оставляйте заявку на сайте

❓ Коллекции в Java: Как устроен WeakHashMap

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

▶️Как работает WeakHashMap?
🔹Ключи со слабой ссылкой. В WeakHashMap ключи хранятся как слабые ссылки (WeakReference). Если объект, используемый в качестве ключа, не имеет других жестких ссылок в приложении, сборщик мусора может освободить память, занятую этим объектом.
🔹Удаление записей. Когда сборщик мусора удаляет объект, используемый в качестве ключа, соответствующая запись автоматически удаляется из карты. Это происходит в фоновом режиме, что помогает предотвращать утечки памяти.

▶️Устройство WeakHashMap
🔹Внутренняя структура. WeakHashMap реализована как хеш-таблица и похожа на HashMap, но отличается тем, что ключи заключены в WeakReference.
🔹Reference Queue. Слабые ссылки на объекты помещаются в очередь ReferenceQueue, когда сборщик мусора очищает объект. WeakHashMap проверяет эту очередь и удаляет записи, ключи которых больше недоступны.

▶️Пример использования WeakHashMap
Допустим, у нас есть задача хранить кэш данных, который должен автоматически очищаться, если ключи больше не используются в других местах программы.

import java.util.Map;
import java.util.WeakHashMap;

public class WeakHashMapExample {
    public static void main(String[] args) {
        Map<Object, String> map = new WeakHashMap<>();
        Object key1 = new Object(); // Создаем ключ
        Object key2 = new Object();

        map.put(key1, "Value 1");
        map.put(key2, "Value 2");

        System.out.println("До GC: " + map); // Выводим карту до сборки мусора

        // Удаляем сильные ссылки на key1 и key2
        key1 = null;
        key2 = null;

        // Запрашиваем сборку мусора
        System.gc();

        // Ждем некоторое время, чтобы GC завершил работу
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("После GC: " + map); // Карта должна быть пустой
    }
}

▶️Выводы
🔹Применение. WeakHashMap подходит для кэшей, где объекты должны быть автоматически удалены, если на них больше нет ссылок.
🔹Особенность. Записи удаляются автоматически при следующем обращении к карте или при очередной сборке мусора.
🔹Ограничение. Значения в WeakHashMap не удаляются при потере ссылки на значение, так как только ключи являются WeakReference.

▶️Примечание
При использовании WeakHashMap важно помнить, что удаление элементов не гарантировано немедленно. Коллекция очистится только после следующей сборки мусора, и если обращение к коллекции происходило редко, слабые ссылки могут оставаться в ней дольше.

🔗Полезные ссылки
Техническое описание Слабой Ссылки (Weak Reference)
Официальная документация Class WeakHashMap от Oracle

⬇️А какую коллекцию для реализаций кэшей выбрал бы ты? Пиши об этом в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент

💡Сколько зарабатывает Machine Learning Engineer?

Продолжаем разбираться с зарплатами в IT👇🏻

🌐 Смотри видео на YouTube
И не забудь подписаться😉

👍 Ставь лайк, если хочешь больше англоязычного контент

❓ Многопоточность. Принцип Happens-before

В многопоточных приложениях Java важным аспектом является предсказуемость поведения программы при одновременном доступе нескольких потоков к общим данным. Принцип happens-before — это модель, которая устанавливает порядок выполнения операций и помогает избежать гонок данных.

В Java принцип happens-before обеспечивает последовательность операций между потоками и определяет, когда изменения в памяти, сделанные одним потоком, будут видны другим потокам. Этот принцип особенно важен для гарантии корректности работы многопоточных приложений.

▶️Основные правила happens-before
🔹Транзитивность. Есть события A, B, C. А выполнилось ранее В, В выполнилось ранее С, тогда А выполнилось ранее С. Это означает, что для любых трёх событий A, B, C,если А произошло раньше В и В произошло раньше С, то А неизбежно должно было произойти раньше С.
🔹Иррефлексивность. Событие А не может произойти ранее А. Это означает, что ни одно событие не может произойти раньше самого себя.
🔹Ассиметричность. Есть события A, B. А выполнилось ранее В, то В не может выполниться ранее А. Это означает, что для любых двух событий А и В, если А произошло раньше В, тогда В не могло произойти раньше А.

▶️Пример использования happens-before в коде
Рассмотрим пример демонстрирующий принцип happens-before работает с volatile переменными.

public class HappensBeforeExample {
    private static volatile boolean flag = false;
    private static int data = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            data = 42;       // Обновляем данные
            flag = true;     // Устанавливаем флаг
        });

        Thread reader = new Thread(() -> {
            if (flag) {      // Проверяем флаг
                System.out.println(data); // Должно напечатать 42
            }
        });

        writer.start();
        writer.join();       // Убеждаемся, что writer завершил свою работу
        reader.start();
        reader.join();       // Убеждаемся, что reader завершил свою работу
    }
}

В этом примере:
🔹Поток writer сначала обновляет переменную data, а затем устанавливает flag в true. Поскольку flag помечена как volatile, операция flag = true happens-before операции flag в потоке reader.
🔹Благодаря этому reader увидит изменение в data, и значение 42 будет корректно выведено.

▶️Преимущества happens-before
Использование принципа happens-before позволяет:
🔹Уменьшить вероятность race condition за счет точного определения порядка операций.
🔹Обеспечить предсказуемость и корректность выполнения программы.
🔹Упростить создание многопоточных программ, минимизируя риски ошибок синхронизации.

⬇️Как часто тебе приходится бороться с race condition? Пиши об этом в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент

Популярные шаблоны микросервисной архитектуры за 20 минут | Паттерны MCA | Microservices

- Какие популярные шаблоны проектирования применяются в микросервисной архитектуре?
- С чего начать изучение микровервисов?
- Что рассказать на собеседовании о микросервисах?
- Какие Шаблоны МСА стоит учить в первую очередь?

В этом видео Макс Добрынин расскажет о множестве популярнейших шаблонах проектирования применяемых при разработки микросервисной архитектуры, которые встречаются на каждом проекте.

Погнали!🔥

❓ Коллекции в Java: Как устроена индексация в HashMap

HashMap — коллекция, которая хранит данные в формате ключ-значение и обеспечивает быструю вставку, поиск и удаление элементов. Основной принцип работы HashMap основан на хэшировании ключей для эффективного доступа к значениям. Индексация в HashMap устроена таким образом, чтобы за O(1) времени выполнять доступ к данным. Давайте рассмотрим, как именно это происходит.

▶️Основные компоненты `HashMap`
🔹Массив бакетов. В основе HashMap лежит массив (table), где каждый элемент — это бакет (bucket). Изначально массив имеет фиксированный размер, который можно задать или оставить по умолчанию.
🔹Бакеты и разрешение коллизий. Если разные ключи попадают в один и тот же бакет, это называется коллизией. Чтобы её разрешить, HashMap использует цепочку связного списка (а начиная с Java 8 — сбалансированное дерево).
🔹Хэш-функция. Для вычисления индекса (положения в массиве) HashMap использует хэш-функцию, которая вычисляет хэш-код для ключа. Хэш-код далее преобразуется в индекс массива для хранения данных.

▶️Процесс индексации в `HashMap`
🔹Вычисление хэш-кода. Когда ключ добавляется в HashMap, сначала вызывается метод hashCode() для вычисления его хэш-кода (целого числа). Этот хэш-код определяет, в какой бакет попадёт элемент.
🔹Распределение по индексу. Хэш-код проходит обработку, чтобы адаптироваться под размер массива бакетов. Обычно это делается побитовой операцией:

int index = (n - 1) & hash;

Здесь n — это длина массива, а hash — хэш-код ключа. Такое распределение позволяет эффективно использовать массив и избежать перерасхода памяти.
🔹Вставка в бакет. Если индекс пуст, ключ и значение сохраняются в соответствующем бакете. Если в бакете уже есть элементы (коллизия), новый элемент добавляется к цепочке, созданной для этого бакета. Начиная с Java 8 и более поздних версий, если количество элементов в бакете превышает порог (8), HashMap преобразует связный список в сбалансированное дерево для увеличения производительности поиска.

▶️Коллизии и производительность
Если два ключа имеют одинаковый хэш-код (коллизия), они попадут в один бакет. В таком случае HashMap сначала просматривает цепочку в бакете, а затем использует метод equals() для поиска конкретного ключа. Начиная с Java 8, при значительном числе коллизий HashMap автоматически преобразует связный список в дерево, что позволяет снизить сложность поиска с O(n) до O(log n).

▶️ Итоги
🔹HashMap использует хэш-функцию для распределения ключей по индексам массива.
🔹Коллизии решаются с помощью цепочек (связного списка или дерева).
🔹Хэширование и деревообразная структура повышают производительность, сводя время доступа к O(1) в большинстве случаев.

🔹HashMap — эффективная структура данных для хранения ассоциативных массивов, обеспечивающая быстрый доступ к данным даже при больших объемах информации.

🔗Полезные ссылки
Официальная документация Class HashMap от Oracle

⬇️А ты можешь пояснить почему методы equals и hashcode так важны при работе с HashMap? Пиши об этом в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент

▶️Как работает `compareAndSet`?
Метод compareAndSet использует примитивы CAS (Compare-And-Swap), которые поддерживаются на уровне процессора. Этот метод:
🔹Сравнивает текущее значение с ожидаемым (первым аргументом).
🔹Если текущее значение совпадает с ожидаемым, обновляет его на новое значение.
🔹Если текущее значение отличается от ожидаемого, метод возвращает false, и операция повторяется.

Пример использования compareAndSet:

AtomicInteger atomicInt = new AtomicInteger(10);
boolean result = atomicInt.compareAndSet(10, 20); // Успешно меняет значение на 20
System.out.println(result);  // true
System.out.println(atomicInt.get()); // 20

▶️Когда использовать `AtomicInteger`?
🔹Когда требуется потокобезопасное обновление целого числа без блокировок.
🔹В высоконагруженных системах, где блокировки могут снизить производительность.
🔹Для небольших задач, где использование synchronized или Lock может быть излишним.

▶️Ограничения `AtomicInteger`
🔹AtomicInteger подходит для простых атомарных операций, но при сложной логике с зависимостями между переменными лучше использовать другие подходы, например, синхронизированные блоки или Lock.
🔹Atomic-операции работают с отдельно взятыми переменными, и AtomicInteger не подходит для операций с несколькими переменными одновременно.

🔗Полезные ссылки
Официальная документация java.util.concurrent.atomic от Oracle
Официальная документация Class AtomicInteger от Oracle

⬇️Тебе уже приходилось использовать атомарные операции в многопоточке? Пиши о своем опыте в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент

❓ Многопоточность в Java: Класс AtomicInteger

Совсем недавно проходил квиз, который был посвящен многопоточности в Java. Один из вопросов затрагивал атомарные операции проводимые над целочисленными значениями. Данный пост прольет свет на детали класса AtomicInteger, его преимущества и недостатки при разработке многопоточных приложений.

▶️Коротко о классе AtomicInteger
Класс AtomicInteger из пакета java.util.concurrent.atomic — это специальный класс для работы с целочисленными значениями в многопоточной среде. Он позволяет выполнять атомарные операции, что особенно полезно при конкурентном доступе нескольких потоков к одной переменной. Основная цель AtomicInteger — обеспечить потокобезопасное обновление целочисленных значений без использования блокировок (lock-free).

▶️Основные особенности `AtomicInteger`
🔹Атомарные операции. Обеспечивает атомарные операции, такие как incrementAndGet(), decrementAndGet() и compareAndSet(), которые выполняются без риска появления гонок данных (data races).
🔹Без блокировок. Все операции в AtomicInteger реализованы без использования явных блокировок (synchronized). Это помогает избежать блокировок и контекстных переключений, делая код более производительным.
🔹Безопасность в многопоточности. AtomicInteger особенно полезен в высоконагруженных многопоточных системах, где синхронизация данных является приоритетом.

▶️Основные методы AtomicInteger
🔹int get() — возвращает текущее значение.
🔹int set(int newValue) — задает значение.
🔹int getAndIncrement() — возвращает текущее значение и увеличивает его на единицу.
🔹int incrementAndGet() — увеличивает значение на единицу и возвращает обновленное значение.
🔹int getAndDecrement() — возвращает текущее значение и уменьшает его на единицу.
🔹int decrementAndGet() — уменьшает значение на единицу и возвращает обновленное значение.
🔹boolean compareAndSet(int expect, int update) — если текущее значение равно expect, устанавливает его в update.

▶️Пример использования AtomicInteger
Рассмотрим пример, в котором несколько потоков увеличивают одно и то же значение, используя AtomicInteger для потокобезопасного обновления.

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicIntegerExample {

    private static AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        // Создаем 10 потоков, каждый из которых увеличит значение счетчика на 1000
        int numberOfThreads = 10;
        Thread[] threads = new Thread[numberOfThreads];

        for (int i = 0; i < numberOfThreads; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.incrementAndGet();
                }
            });
            threads[i].start();
        }

        // Ждем завершения всех потоков
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        System.out.println("Значение счетчика: " + counter.get()); // Ожидается 10000
    }
}

🤚 Собираем новую группу Middle Java Developer уже в ноябре

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

За 3 месяца работы над проектом вы:

— Освоите современный набор навыков и технологий, которые необходимы для перехода на более высокооплачиваемый проект;
— Получите недостающий коммерческий опыт разработки;
— Разместите готовый проект в портфолио;
— Получите обратную связь и постоянную поддержку от практикующих разработчиков уровня Senior+;

А групповая динамика и коллеги не дадут вам возможности “соскочить” или “забить”.

На проекте используются следующий технологии:
- Java (последние версии)
- Spring Boot
- Spring Framework (WebFlux, R2DBC, Security, др.)
- Slf4j, Logback, Distributed Logging
- JUnit, AssertJ, Mockito
- Maven, Gradle
- SQL, JPA, Hibernate
- Docker
- Kafka/RabbitMQ
- Microservices

Нефункциональные требования к проекту:
⁃ Покрытие тестами: unit, integration, e2e
⁃ Обработка не менее 50-запросов в секунду (включая fun-out)
⁃ Масштабируемость
⁃ Высокий уровень доступности
⁃ Трассирование запросов

Архитектура: Микросервисная, 5-сервисов

Тип коммуникации: Синхронный и асинхронный

Как устроена стажировка на платформе:

1️⃣ Группа за 3 месяца реализует отдельный сервис в рамках целого проекта.

2️⃣ К каждой группе прикрепляется практикующий разработчик уровня Senior, который выступает ментором, распределяет задачи внутри команды, проводит код ревью и конечно же приходит на помощь в случае, когда появляются вопросы.

3️⃣ Общение в группе происходит на постоянной основе, благодаря чему вы прокачаете навыки командной разработки и свои soft skills.

4️⃣ Группа встречается 3 раза в неделю на митинге по часу, где происходит обсуждение текущих задач, код-ревью и решение вопросов.

В результате за 3 месяца вы реализуете в команде полноценный проект, который даст вам возможность двинуться дальше по карьерной лестнице.
____________________

Количество мест строго ограничено, хватит топтаться на месте, пора сделать скачок в своей карьере за 3 месяца👇🏻

Чтобы успеть забронировать место на проекте пишите менеджеру напрямую или оставляйте заявку на нашем сайте

🔝Популярные задачи с собеседований: Является ли строка палиндромом

▶️Кому эта задача подойдет?
Это несложная задача проверяющая алгоритмическое мышление, знание структур данных и владение языком программирования используемого при ее реализации, что делает её подходящей для уровня Intern Java Developer и Junior Java Developer.

▶️Описание
Необходимо реализовать метод, который проверяет, является ли заданная строка палиндромом. Палиндром — это слово, фраза или последовательность символов, которая читается одинаково как слева направо, так и справа налево (игнорируя пробелы, регистр букв и знаки препинания).

▶️Условия
🔹Игнорировать регистр букв.
🔹Удалить все неалфавитные символы.
🔹Проверить, равна ли строка самой себе, если её прочитать в обратном порядке.

▶️Чему стоит уделить внимание во время собеседования?
🔹Какова сложность выполнения данного алгоритма?
🔹Как можно улучшить решение, чтобы избежать создания новой строки для сравнения?
🔹Какой подход вы бы использовали, если строка была бы очень длинной?

⬇️ Уже решил эту задачу или есть варианты решения? Пиши в комментариях
👍 Поставь лайк этому посту, если тебе нравятся наш контент