Просмотр кода страницы Программирование:Лабораторная работа №7

<span id="методичка-для-подготовки-к-защите-лабораторной-работы"></span>
== Методичка для подготовки к защите лабораторной работы ==

<span id="раздел-1.-основы-многопоточности"></span>
=== Раздел 1. Основы многопоточности ===

<span id="многопоточность.-класс-thread-интерфейс-runnable"></span>
==== '''1.1. Многопоточность. Класс <code>Thread</code>, интерфейс <code>Runnable</code>''' ====

'''Что такое многопоточность?'''

* '''Ответ:''' Многопоточность — это способ выполнения программы, при котором несколько потоков (threads) исполняются одновременно (или псевдо-одновременно на одноядерном процессоре) в рамках одного процесса. У всех потоков одного процесса общая память (heap), что позволяет им легко обмениваться данными, но также создаёт проблемы с синхронизацией доступа к этим данным.

'''Для чего она нужна?'''

* '''Ответ:'''
*# '''Повышение производительности:''' На многоядерных системах задачи можно распараллелить и выполнять действительно одновременно, что ускоряет вычисления.
*# '''Улучшение отклика интерфейса (Responsiveness):''' В GUI-приложениях (например, Swing, Android) долгие операции (загрузка файла, сетевой запрос) выносятся в фоновый поток, чтобы основной поток (UI Thread) не “зависал” и продолжал обрабатывать действия пользователя.
*# '''Эффективное использование ресурсов:''' Пока один поток ждёт ответа от сети или диска (I/O operation), процессор может выполнять другой поток.

'''Как создать поток в Java?'''

<ul>
<li>'''Ответ:''' Есть два основных способа:
<ol style="list-style-type: decimal;">
<li>'''Наследование от класса <code>Thread</code>:'''
<ul>
<li>Создать класс, который наследуется от <code>java.lang.Thread</code>.</li>
<li>Переопределить его метод <code>run()</code>, в котором будет содержаться логика потока.</li>
<li>Создать экземпляр этого класса и вызвать его метод <code>start()</code>. '''Важно:''' именно <code>start()</code>, а не <code>run()</code>. Вызов <code>run()</code> просто выполнит код в текущем потоке, а <code>start()</code> создаст новый системный поток и в нём уже вызовет <code>run()</code>.</li></ul>

<syntaxhighlight lang="java">class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Поток, созданный наследованием, запущен: " + Thread.currentThread().getName());
    }
}

// Запуск:
MyThread myThread = new MyThread();
myThread.start();</syntaxhighlight></li>
<li>'''Реализация интерфейса <code>Runnable</code>:'''
<ul>
<li>Создать класс, который реализует интерфейс <code>java.lang.Runnable</code>.</li>
<li>Реализовать его единственный метод <code>run()</code>.</li>
<li>Создать экземпляр этого класса, передать его в конструктор класса <code>Thread</code> и вызвать у объекта <code>Thread</code> метод <code>start()</code>.</li></ul>

<syntaxhighlight lang="java">class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Поток, созданный через Runnable, запущен: " + Thread.currentThread().getName());
    }
}

// Запуск:
MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();

// Или с помощью лямбда-выражения (с Java 8):
Thread lambdaThread = new Thread(() -> System.out.println("Лямбда-поток запущен!"));
lambdaThread.start();</syntaxhighlight></li></ol>
</li></ul>

'''Какой способ лучше и почему?'''

* '''Ответ:''' '''Реализация <code>Runnable</code> является предпочтительным способом.'''
** '''Причина 1: Гибкость и композиция.''' Java не поддерживает множественное наследование классов. Если ваш класс уже от чего-то наследуется, вы не сможете сделать его потоком через <code>extends Thread</code>. Интерфейсы же можно реализовывать в любом количестве. Это соответствует принципу “предпочитайте композицию наследованию”.
** '''Причина 2: Разделение ответственности.''' Класс <code>Thread</code> отвечает за управление потоком (его запуск, прерывание, состояние). Интерфейс <code>Runnable</code> отвечает только за задачу (<code>task</code>), которую нужно выполнить. Разделяя задачу от исполнителя, мы делаем код более чистым и гибким. Одну и ту же задачу (<code>Runnable</code>) можно передать разным исполнителям (например, в пул потоков).


-----

<span id="модификатор-synchronized"></span>
==== '''1.2. Модификатор <code>synchronized</code>''' ====

'''Что такое “состояние гонки” (race condition)?'''

* '''Ответ:''' Это ситуация в многопоточной среде, когда результат выполнения кода зависит от того, в какой последовательности потоки получат доступ к общему ресурсу. Обычно это приводит к непредсказуемым и ошибочным результатам. Классический пример — инкремент общего счётчика.

'''Как <code>synchronized</code> решает эту проблему?'''

* '''Ответ:''' Модификатор <code>synchronized</code> обеспечивает '''взаимное исключение (mutual exclusion)'''. Он гарантирует, что только один поток может выполнять защищённый (<code>synchronized</code>) блок кода в один момент времени для одного и того же объекта-монитора.

'''Как он работает “под капотом”?'''

<ul>
<li>'''Ответ:''' Каждый объект в Java имеет ассоциированный с ним '''внутренний замок (intrinsic lock)''', или '''монитор'''.
<ul>
<li>Когда поток входит в <code>synchronized</code> метод экземпляра, он пытается захватить монитор объекта <code>this</code>.</li>
<li>Когда поток входит в <code>static synchronized</code> метод, он пытается захватить монитор объекта <code>ClassName.class</code>.</li>
<li>Когда поток входит в <code>synchronized</code> блок, он пытается захватить монитор объекта, указанного в скобках.</li></ul>

Если замок свободен, поток захватывает его, выполняет код и освобождает замок при выходе из блока (даже при исключении). Если замок занят другим потоком, текущий поток блокируется и ждёт освобождения замка.</li></ul>

'''Где можно использовать <code>synchronized</code>?'''

<ul>
<li><p>'''1. Методы экземпляра:'''</p>
<syntaxhighlight lang="java">public synchronized void increment() {
    // Код, защищённый монитором объекта 'this'
    counter++;
}</syntaxhighlight></li>
<li><p>'''2. Статические методы:'''</p>
<syntaxhighlight lang="java">public static synchronized void staticIncrement() {
    // Код, защищённый монитором объекта 'MyClass.class'
    staticCounter++;
}</syntaxhighlight></li>
<li><p>'''3. Блоки кода:'''</p>
<syntaxhighlight lang="java">private final Object lock = new Object(); // Явный объект для блокировки

public void doWork() {
    // ... какой-то код, не требующий синхронизации ...
    synchronized (lock) { // Захват монитора объекта 'lock'
        // Критическая секция: только один поток одновременно
    }
    // ... другой код ...
}</syntaxhighlight></li></ul>

'''Почему <code>synchronized(this)</code> может быть плохой практикой?'''

* '''Ответ:''' Если вы используете <code>synchronized(this)</code> или <code>synchronized</code> метод, вы выставляете монитор вашего объекта наружу. Любой внешний код может также синхронизироваться по вашему объекту и вызвать '''взаимную блокировку (deadlock)''' или проблемы с производительностью. Использование приватного финального объекта (<code>private final Object lock = new Object();</code>) является более безопасной и инкапсулированной практикой.


-----

<span id="раздел-2.-механизмы-координации-потоков"></span>
=== Раздел 2. Механизмы координации потоков ===

<span id="методы-wait-notify-notifyall"></span>
==== '''2.1. Методы <code>wait()</code>, <code>notify()</code>, <code>notifyAll()</code>''' ====

'''Для чего нужны эти методы, если уже есть <code>synchronized</code>?'''

* '''Ответ:''' <code>synchronized</code> решает проблему ''взаимного исключения'' (кто сейчас работает с ресурсом). Методы <code>wait()</code>, <code>notify()</code>, <code>notifyAll()</code> решают проблему '''координации''' или '''взаимодействия''' потоков (когда один поток должен дождаться определённого условия, которое создаст другой поток). Классический пример — паттерн “Производитель-Потребитель”.

'''Как они работают?'''

* '''<code>wait()</code>:''' Поток, вызвавший <code>wait()</code> на объекте-мониторе, '''немедленно освобождает замок''' этого монитора и переходит в состояние ожидания (WAITING). Он будет “спать”, пока другой поток не вызовет <code>notify()</code> или <code>notifyAll()</code> на '''этом же самом мониторе'''.
* '''<code>notify()</code>:''' “Будит” '''один случайный''' поток, ожидающий на этом мониторе. Пробуждённый поток не начинает выполняться сразу, а переходит в состояние BLOCKED и пытается снова захватить замок.
* '''<code>notifyAll()</code>:''' “Будит” '''все''' потоки, ожидающие на этом мониторе. Они все начинают бороться за замок, но только один его получит и продолжит выполнение.

'''Ключевое правило:''' Методы <code>wait()</code>, <code>notify()</code>, <code>notifyAll()</code> '''обязаны''' вызываться только из <code>synchronized</code> блока (или метода), который синхронизирован по тому же объекту. Иначе будет выброшено исключение <code>IllegalMonitorStateException</code>.

'''Почему это правило существует?'''

<ul>
<li>'''Ответ:''' Чтобы избежать “потерянного пробуждения” (lost wakeup). Представьте:
<ol style="list-style-type: decimal;">
<li>Поток A проверяет условие (например, <code>while (list.isEmpty())</code>) и решает, что нужно ждать.</li>
<li>''В этот момент'' планировщик переключает контекст на Поток B.</li>
<li>Поток B добавляет элемент в список и вызывает <code>notify()</code>.</li>
<li>Планировщик возвращает управление Потоку A.</li>
<li>Поток A вызывает <code>wait()</code> и засыпает навсегда, так как сигнал <code>notify()</code> уже был отправлен и потерян.</li></ol>

<code>synchronized</code> блок гарантирует, что проверка условия и вызов <code>wait()</code> будут атомарной операцией относительно изменения этого условия и вызова <code>notify()</code>.</li></ul>

'''Почему <code>wait()</code> всегда нужно использовать в цикле <code>while</code>, а не в <code>if</code>?'''

<syntaxhighlight lang="java">synchronized (monitor) {
    while (conditionIsNotMet) { // ПРАВИЛЬНО
        monitor.wait();
    }
    // ... делать работу ...
}

// if (conditionIsNotMet) { monitor.wait(); } // НЕПРАВИЛЬНО</syntaxhighlight>
* '''Ответ:''' Из-за феномена '''“ложного пробуждения” (spurious wakeup)'''. Спецификация Java допускает, что поток может проснуться из <code>wait()</code> без вызова <code>notify()</code>/<code>notifyAll()</code>. Это редкое, но возможное явление. Цикл <code>while</code> гарантирует, что после пробуждения поток '''повторно проверит условие'''. Если пробуждение было ложным, он просто снова уснёт.

'''<code>notify()</code> vs <code>notifyAll()</code>: что выбрать?'''

* '''Ответ:''' <code>notifyAll()</code> является более безопасным и предпочтительным выбором в большинстве случаев. <code>notify()</code> можно использовать для оптимизации, только если вы '''абсолютно уверены''', что:
*# Все ожидающие потоки взаимозаменяемы (любой из них может продолжить работу).
*# Только одно условие изменилось, и его хватит только для одного потока. В остальных случаях использование <code>notify()</code> может привести к тому, что “проснётся” не тот поток, и система “зависнет”.


-----

<span id="интерфейсы-lock-и-condition"></span>
==== '''2.2. Интерфейсы <code>Lock</code> и <code>Condition</code>''' ====

'''Зачем нужны <code>Lock</code> и <code>Condition</code>, если есть <code>synchronized</code> и <code>wait</code>/<code>notify</code>?'''

* '''Ответ:''' <code>java.util.concurrent.locks.Lock</code> — это более гибкая и мощная альтернатива <code>synchronized</code>.
** '''Возможность попробовать захватить замок:''' Метод <code>tryLock()</code> пытается захватить замок и немедленно возвращает <code>true</code> или <code>false</code>, не блокируя поток. Есть и версия с таймаутом <code>tryLock(long time, TimeUnit unit)</code>.
** '''Прерываемые блокировки:''' Метод <code>lockInterruptibly()</code> позволяет прервать поток, пока он ждёт захвата замка. <code>synchronized</code> блок не может быть прерван.
** '''Честность (Fairness):''' Конструктор <code>ReentrantLock</code> (основная реализация <code>Lock</code>) принимает флаг <code>fair</code>. В “честном” режиме замок будет отдан потоку, который дольше всех ждёт. <code>synchronized</code> не гарантирует честности.
** '''Несколько условий:''' Один <code>Lock</code> может быть ассоциирован с несколькими объектами <code>Condition</code>. Это аналог <code>wait/notify</code>, но позволяет группировать ожидающие потоки по разным условиям. У <code>synchronized</code> только один набор ожидающих потоков на монитор.

'''Как правильно использовать <code>Lock</code>?'''

<ul>
<li><p>'''Ответ:''' Всегда использовать конструкцию <code>try...finally</code>. Это критически важно, потому что в отличие от <code>synchronized</code>, замок не освободится автоматически при исключении.</p>
<syntaxhighlight lang="java">private final Lock lock = new ReentrantLock();

public void doWork() {
    lock.lock(); // Захват замка
    try {
        // Критическая секция
    } finally {
        lock.unlock(); // Гарантированное освобождение замка в блоке finally
    }
}</syntaxhighlight></li></ul>

'''Как использовать <code>Condition</code>?'''

<ul>
<li><p>'''Ответ:''' <code>Condition</code> привязывается к <code>Lock</code>. Его методы <code>await()</code> (аналог <code>wait()</code>), <code>signal()</code> (аналог <code>notify()</code>), <code>signalAll()</code> (аналог <code>notifyAll()</code>) работают так же, но для конкретного условия.</p>
<syntaxhighlight lang="java">class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition notFull  = lock.newCondition(); // Условие: буфер не полон
    final Condition notEmpty = lock.newCondition(); // Условие: буфер не пуст

    final Object[] items = new Object[100];
    int putptr, takeptr, count;

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length)
                notFull.await(); // Ждем, пока появится место
            items[putptr] = x;
            if (++putptr == items.length) putptr = 0;
            ++count;
            notEmpty.signal(); // Сигнализируем, что буфер больше не пуст
        } finally {
            lock.unlock();
        }
    }
    // ... метод take() с await() на notEmpty и signal() на notFull ...
}</syntaxhighlight></li></ul>


-----

<span id="раздел-3.-утилиты-из-java.util.concurrent"></span>
=== Раздел 3. Утилиты из <code>java.util.concurrent</code> ===

<span id="классы-синхронизаторы"></span>
==== '''3.1. Классы-синхронизаторы''' ====

'''Что это такое и зачем они нужны?'''

* '''Ответ:''' Это готовые высокоуровневые классы для решения типовых задач синхронизации, которые сложны в реализации через <code>wait/notify</code> или <code>Lock</code>.
* '''<code>Semaphore</code> (Семафор):'''
** '''Аналогия:''' Парковка с ограниченным числом мест или клуб со строгим фейс-контролем, пропускающим внутрь не более N человек.
** '''Что делает:''' Ограничивает количество потоков, которые могут одновременно получить доступ к некоторому ресурсу.
** '''Методы:''' <code>acquire()</code> — запрашивает разрешение (если нет, блокируется), <code>release()</code> — освобождает разрешение.
** '''Пример использования:''' Ограничение количества одновременных подключений к базе данных.
* '''<code>CountDownLatch</code> (Защёлка обратного отсчёта):'''
** '''Аналогия:''' Стартовые ворота на скачках. Они не откроются, пока все жокеи не будут готовы. Или судья на финише, который ждёт всех бегунов.
** '''Что делает:''' Позволяет одному или нескольким потокам ждать, пока не завершится N операций, выполняемых в других потоках. Защёлка одноразовая — после того, как счётчик дошёл до нуля, её нельзя использовать повторно.
** '''Методы:''' <code>countDown()</code> — уменьшает счётчик на 1, <code>await()</code> — блокирует поток, пока счётчик не станет равен 0.
** '''Пример использования:''' Основной поток ждёт, пока все рабочие потоки не завершат инициализацию.
* '''<code>CyclicBarrier</code> (Циклический барьер):'''
** '''Аналогия:''' Группа туристов, договорившихся встретиться у достопримечательности, чтобы продолжить путь вместе. Никто не уходит, пока все не соберутся.
** '''Что делает:''' Позволяет группе потоков ждать друг друга в определённой точке (барьере) перед тем, как продолжить выполнение. Барьер можно использовать повторно (<code>cyclic</code>).
** '''Метод:''' <code>await()</code> — поток сообщает, что он достиг барьера, и блокируется, пока все остальные потоки не вызовут <code>await()</code>. Последний пришедший поток “сбрасывает” барьер и все продолжают работу.
** '''Пример использования:''' Распараллеливание сложного вычисления, где каждый этап зависит от результатов всех потоков на предыдущем этапе.
* '''<code>Phaser</code> (Фазер):'''
** '''Что делает:''' Более гибкая и мощная версия <code>CyclicBarrier</code>. Позволяет динамически изменять количество участвующих в синхронизации потоков (сторон).
** '''Пример использования:''' Сложные многофазные вычисления с переменным количеством участников на каждом этапе.

'''Разница между <code>CountDownLatch</code> и <code>CyclicBarrier</code>?'''

* <code>CountDownLatch</code> — это “один ко многим” (один или несколько потоков ждут завершения N других операций). Он одноразовый.
* <code>CyclicBarrier</code> — это “многие к многим” (N потоков ждут друг друга). Он многоразовый (циклический).


-----

<span id="volatile-и-атомарные-типы"></span>
==== '''3.2. <code>volatile</code> и Атомарные типы''' ====

'''Что гарантирует модификатор <code>volatile</code>?'''

* '''Ответ:''' <code>volatile</code> решает проблему '''видимости (visibility)''' переменных между потоками. Он гарантирует две вещи:
*# '''Видимость:''' Любая запись в <code>volatile</code> переменную одним потоком становится немедленно видна всем другим потокам, которые читают эту переменную. Это предотвращает ситуацию, когда поток работает с устаревшим значением переменной из своего локального кэша процессора.
*# '''Упорядочивание (Happens-Before):''' Запись в <code>volatile</code> переменную устанавливает отношение “происходит-до” (happens-before). Все операции, которые были ''до'' записи в <code>volatile</code> переменную в одном потоке, будут видны другому потоку ''после'' чтения из этой же <code>volatile</code> переменной.

'''Чего <code>volatile</code> НЕ гарантирует?'''

* '''Ответ:''' '''Атомарности''' для составных операций (таких как инкремент <code>i++</code>). Операция <code>i++</code> состоит из трёх шагов: чтение старого значения, вычисление нового, запись нового. Между этими шагами другой поток может изменить значение <code>i</code>, и результат будет некорректным. <code>volatile</code> гарантирует только, что каждый из этих шагов будет виден другим потокам, но не то, что вся троица выполнится как единое целое.

'''Для чего тогда он нужен?'''

<ul>
<li>'''Ответ:''' Для простых флагов и указателей, где запись не зависит от предыдущего значения.
<ul>
<li>'''Пример:''' Флаг для остановки потока.</li></ul>

<syntaxhighlight lang="java">private volatile boolean running = true;

public void run() {
    while (running) {
        // делать работу
    }
}

public void stopThread() {
    running = false; // Эта запись будет видна потоку в цикле while
}</syntaxhighlight></li></ul>

'''Что такое атомарные типы и как они решают проблему?'''

<ul>
<li>'''Ответ:''' Атомарные типы — это классы из пакета <code>java.util.concurrent.atomic</code> (например, <code>AtomicInteger</code>, <code>AtomicLong</code>, <code>AtomicBoolean</code>), которые предоставляют методы для выполнения атомарных операций над переменными.</li>
<li>Они решают проблему атомарности для операций типа “проверить-и-изменить”, как инкремент.</li>
<li>'''Как работают:''' “Под капотом” они используют низкоуровневые, аппаратно-поддерживаемые инструкции '''CAS (Compare-And-Swap)'''.
<ul>
<li>'''CAS-операция''' — это атомарная инструкция, которая принимает три аргумента: адрес в памяти (V), ожидаемое старое значение (A) и новое значение (B). Она атомарно обновляет значение в V на B, только если текущее значение в V равно A. В противном случае ничего не происходит.</li>
<li>Методы вроде <code>incrementAndGet()</code> у <code>AtomicInteger</code> работают в цикле: читают текущее значение, вычисляют новое, а затем с помощью CAS пытаются записать новое значение, если старое не изменилось. Если изменилось — повторяют операцию. Это называется '''lock-free''' или '''optimistic locking''', так как не используется блокировка потока.</li></ul>

<syntaxhighlight lang="java">// НЕ ПОТОКОБЕЗОПАСНО
private int counter = 0;
public void increment() { counter++; }

// ПОТОКОБЕЗОПАСНО
private AtomicInteger atomicCounter = new AtomicInteger(0);
public void increment() { atomicCounter.incrementAndGet(); }</syntaxhighlight></li></ul>


-----

<span id="коллекции-из-java.util.concurrent"></span>
==== '''3.3. Коллекции из <code>java.util.concurrent</code>''' ====

'''Чем <code>ConcurrentHashMap</code> лучше <code>Collections.synchronizedMap(new HashMap&lt;&gt;())</code>?'''

* '''<code>Collections.synchronizedMap</code>:''' Оборачивает обычную карту и делает '''каждый её метод''' <code>synchronized</code>. Это означает, что в любой момент времени с картой может работать только один поток (чтение или запись). Это '''блокировка на всю коллекцию''', что сильно снижает производительность при большом количестве потоков.
* '''<code>ConcurrentHashMap</code>:''' Использует более сложный механизм '''блокировки по сегментам (или бакетам в новых версиях)'''. Чтение в большинстве случаев вообще не требует блокировок. Операции записи блокируют только ту часть карты (сегмент), которая затрагивается, а не всю карту целиком. Это позволяет множеству потоков одновременно работать с разными частями карты, обеспечивая '''высокую степень параллелизма'''.

'''Какие ещё полезные concurrent-коллекции существуют?'''

* '''<code>CopyOnWriteArrayList</code>:'''
** '''Принцип работы:''' Любая операция изменения (<code>add</code>, <code>remove</code>, <code>set</code>) создаёт '''полную копию''' внутреннего массива, вносит изменения в копию и затем атомарно заменяет ссылку на старый массив новой.
** '''Плюсы:''' Операции чтения (<code>get</code>, <code>iterator</code>) очень быстрые, так как не требуют никаких блокировок и работают с неизменяемым “снимком” массива. Итераторы никогда не бросят <code>ConcurrentModificationException</code>.
** '''Минусы:''' Операции записи очень дорогие (копирование всего массива).
** '''Когда использовать:''' Когда количество чтений '''многократно''' превышает количество записей. Типичный пример — список слушателей (listeners).
* '''Блокирующие очереди (<code>BlockingQueue</code>):'''
** '''Что это:''' Это интерфейс для очередей, которые являются потокобезопасными и имеют дополнительные методы, блокирующие поток, если операция не может быть выполнена немедленно.
** '''Методы:'''
*** <code>put(E e)</code>: добавляет элемент, блокируя поток, если очередь полна.
*** <code>take()</code>: извлекает элемент, блокируя поток, если очередь пуста.
** '''Реализации:''' <code>ArrayBlockingQueue</code> (на массиве, ограниченный размер), <code>LinkedBlockingQueue</code> (на связном списке, опционально ограниченный), <code>SynchronousQueue</code> (очередь без внутреннего буфера, операция <code>put</code> ждёт <code>take</code>).
** '''Когда использовать:''' Это ключевой компонент для паттерна '''“Производитель-Потребитель”'''. Производители кладут задачи в очередь, потребители забирают их оттуда.


-----

<span id="раздел-4.-управление-потоками"></span>
=== Раздел 4. Управление потоками ===

<span id="executor-executorservice-callable-future"></span>
==== '''4.1. <code>Executor</code>, <code>ExecutorService</code>, <code>Callable</code>, <code>Future</code>''' ====

'''Зачем нужен <code>Executor Framework</code>, если можно создавать потоки через <code>new Thread().start()</code>?'''

<ul>
<li>'''Ответ:''' Ручное управление потоками — это плохая практика:
<ol style="list-style-type: decimal;">
<li>'''Высокие накладные расходы:''' Создание и уничтожение системного потока — дорогая операция.</li>
<li>'''Неограниченное создание потоков:''' Если на каждый запрос создавать новый поток, можно легко исчерпать ресурсы системы и вызвать её крах (<code>OutOfMemoryError</code>).</li>
<li>'''Сложность управления:''' Нет простого способа управлять жизненным циклом потоков, получать результаты их работы или обрабатывать исключения.</li></ol>

<code>Executor Framework</code> абстрагирует создание и управление потоками. Вы просто передаёте ему задачи (<code>Runnable</code> или <code>Callable</code>), а он сам решает, как и когда их выполнять, переиспользуя потоки.</li></ul>

'''Расскажите про иерархию интерфейсов.'''

* '''<code>Executor</code>:''' Базовый интерфейс с одним методом <code>execute(Runnable command)</code>. Он просто принимает задачу на выполнение.
* '''<code>ExecutorService</code>:''' Расширяет <code>Executor</code>. Добавляет:
** '''Управление жизненным циклом:''' <code>shutdown()</code> (перестаёт принимать новые задачи, но выполняет уже начатые), <code>shutdownNow()</code> (пытается прервать все активные задачи и возвращает список невыполненных).
** '''Возможность отправки <code>Callable</code>:''' <code>submit(Callable&lt;T&gt; task)</code>.
* '''<code>Callable&lt;V&gt;</code>:''' Аналог <code>Runnable</code>, но его метод <code>call()</code> может возвращать результат типа <code>V</code> и бросать проверяемое исключение.
* '''<code>Future&lt;V&gt;</code>:''' Объект-заместитель, который представляет результат асинхронной операции.
** '''Методы:'''
*** <code>get()</code>: Блокирует текущий поток и ждёт завершения задачи, после чего возвращает её результат. Если в задаче было исключение, <code>get()</code> бросит <code>ExecutionException</code>.
*** <code>isDone()</code>: Проверяет, завершена ли задача.
*** <code>cancel(boolean mayInterruptIfRunning)</code>: Пытается отменить задачу.


-----

<span id="пулы-потоков-thread-pools"></span>
==== '''4.2. Пулы потоков (Thread Pools)''' ====

'''Что такое пул потоков и зачем он нужен?'''

* '''Ответ:''' Пул потоков — это набор заранее созданных рабочих потоков (<code>worker threads</code>), которые готовы выполнять задачи. Когда задача поступает, она передаётся одному из свободных потоков в пуле. После выполнения задачи поток не умирает, а возвращается в пул и ждёт следующей задачи.
* '''Преимущества:'''
*# '''Сокращение накладных расходов:''' Потоки переиспользуются, а не создаются заново.
*# '''Контроль над ресурсами:''' Ограничивается максимальное число одновременно работающих потоков, что предотвращает истощение ресурсов.
*# '''Упрощение управления:''' Предоставляет готовые механизмы для постановки задач в очередь и управления их выполнением.

'''Как создать пул потоков?'''

* '''Ответ:''' Через статические фабричные методы класса <code>java.util.concurrent.Executors</code>:
** '''<code>Executors.newFixedThreadPool(int nThreads)</code>:''' Создаёт пул с '''фиксированным''' числом потоков. Если все потоки заняты, новые задачи помещаются в неограниченную очередь. Хорош для задач, интенсивно использующих CPU.
** '''<code>Executors.newCachedThreadPool()</code>:''' Создаёт пул, который '''переиспользует''' существующие потоки, а если их нет — создаёт новые. Неиспользуемые потоки удаляются через 60 секунд. Подходит для большого количества короткоживущих задач. '''Опасно:''' может создать неограниченное число потоков.
** '''<code>Executors.newSingleThreadExecutor()</code>:''' Пул из одного потока. Гарантирует, что все задачи будут выполняться последовательно, в порядке их поступления.
** '''<code>Executors.newScheduledThreadPool(int corePoolSize)</code>:''' Пул для выполнения отложенных или периодических задач.

'''Важное замечание для защиты:''' В реальных (production) системах использовать фабрики <code>Executors</code> не рекомендуется, так как они создают пулы с неограниченными очередями (<code>Fixed</code>, <code>Single</code>) или неограниченным числом потоков (<code>Cached</code>), что может привести к <code>OutOfMemoryError</code>. Правильным подходом является прямое создание экземпляра <code>ThreadPoolExecutor</code>, где можно точно настроить все параметры (размер ядра, максимальный размер, тип очереди, política отвержения).


-----

<span id="раздел-5.-jdbc-java-database-connectivity"></span>
=== Раздел 5. JDBC (Java Database Connectivity) ===

<span id="порядок-взаимодействия-с-бд.-drivermanager-connection"></span>
==== '''5.1. Порядок взаимодействия с БД. <code>DriverManager</code>, <code>Connection</code>''' ====

'''Опишите стандартный алгоритм работы с БД через JDBC.'''

* '''Ответ:'''
*# '''Загрузка драйвера БД (шаг устарел):''' Раньше требовался вызов <code>Class.forName(&quot;com.mysql.cj.jdbc.Driver&quot;)</code>. В современных версиях JDBC (4.0+) драйверы загружаются автоматически с помощью механизма <code>ServiceLoader</code>, если jar-файл драйвера есть в classpath. Но знать об этом шаге нужно.
*# '''Получение соединения (<code>Connection</code>):''' Вызвать статический метод <code>DriverManager.getConnection(url, user, password)</code>.
*#* <code>url</code>: строка специального формата, указывающая тип БД, хост, порт и имя базы (например, <code>jdbc:postgresql://localhost:5432/mydatabase</code>).
*#* <code>user</code>, <code>password</code>: учётные данные для доступа.
*# '''Создание объекта для выполнения запроса (<code>Statement</code> или <code>PreparedStatement</code>):''' Вызвать у объекта <code>Connection</code> метод <code>createStatement()</code> или <code>prepareStatement()</code>.
*# '''Выполнение SQL-запроса:'''
*#* Для <code>SELECT</code>: <code>executeQuery()</code>, возвращает <code>ResultSet</code>.
*#* Для <code>INSERT</code>, <code>UPDATE</code>, <code>DELETE</code>: <code>executeUpdate()</code>, возвращает <code>int</code> (количество изменённых строк).
*# '''Обработка результата (<code>ResultSet</code>):''' Если был <code>SELECT</code>, обойти <code>ResultSet</code> в цикле <code>while(rs.next())</code> и извлечь данные.
*# '''Закрытие ресурсов:''' '''Критически важный шаг!''' Ресурсы (<code>ResultSet</code>, <code>Statement</code>, <code>Connection</code>) должны быть закрыты в порядке, обратном их созданию. Лучше всего это делать в блоке <code>finally</code> или с помощью конструкции <code>try-with-resources</code> (предпочтительно с Java 7+).

'''Пример с <code>try-with-resources</code>:'''

<syntaxhighlight lang="java">String url = "jdbc:...";
String user = "user";
String password = "password";
String sql = "SELECT * FROM users WHERE city = ?";

try (Connection conn = DriverManager.getConnection(url, user, password);
     PreparedStatement pstmt = conn.prepareStatement(sql)) {

    pstmt.setString(1, "Moscow");
    try (ResultSet rs = pstmt.executeQuery()) {
        while (rs.next()) {
            System.out.println(rs.getString("name") + ", " + rs.getInt("age"));
        }
    }
} catch (SQLException e) {
    e.printStackTrace();
}</syntaxhighlight>
'''Роль <code>DriverManager</code> и <code>Connection</code>'''

* '''<code>DriverManager</code>:''' Класс-менеджер, который управляет набором зарегистрированных JDBC-драйверов. Его основная задача — выбрать подходящий драйвер для указанного URL и установить с его помощью соединение с БД.
* '''<code>Connection</code>:''' Интерфейс, представляющий сессию (соединение) с конкретной базой данных. Все SQL-запросы выполняются в контексте этого соединения. Также <code>Connection</code> отвечает за управление транзакциями (<code>setAutoCommit</code>, <code>commit</code>, <code>rollback</code>).


-----

<span id="statement-preparedstatement-resultset-rowset"></span>
==== '''5.2. <code>Statement</code>, <code>PreparedStatement</code>, <code>ResultSet</code>, <code>RowSet</code>''' ====

'''<code>Statement</code> vs <code>PreparedStatement</code>: в чём разница и что лучше?'''

* '''Ответ:''' Это один из самых важных вопросов по JDBC. '''<code>PreparedStatement</code> почти всегда лучше <code>Statement</code>.'''

{| class="wikitable"
|-
! style="text-align: left;"| Характеристика
! style="text-align: left;"| <code>Statement</code>
! style="text-align: left;"| <code>PreparedStatement</code>
|-
| style="text-align: left;"| '''Принцип работы'''
| style="text-align: left;"| Каждый раз отправляет и компилирует SQL-запрос на сервере БД.
| style="text-align: left;"| Запрос '''предварительно компилируется''' (pre-compiled) на сервере БД один раз. Затем можно многократно выполнять его с разными параметрами.
|-
| style="text-align: left;"| '''Производительность'''
| style="text-align: left;"| Ниже, особенно при многократном выполнении однотипных запросов.
| style="text-align: left;"| '''Выше''', так как СУБД не тратит время на повторный парсинг и компиляцию SQL-кода.
|-
| style="text-align: left;"| '''Безопасность'''
| style="text-align: left;"| '''Уязвим к SQL-инъекциям'''. Параметры вставляются в строку запроса конкатенацией, что позволяет злоумышленнику внедрить вредоносный SQL-код.
| style="text-align: left;"| '''Защищает от SQL-инъекций'''. Параметры передаются отдельно от SQL-кода через <code>setXXX()</code> методы. Драйвер сам заботится об их корректном экранировании.
|-
| style="text-align: left;"| '''Использование'''
| style="text-align: left;"| <code>connection.createStatement()</code>
| style="text-align: left;"| <code>connection.prepareStatement(&quot;SELECT * FROM users WHERE id = ?&quot;)</code>
|}

'''Что такое SQL-инъекция?'''

<ul>
<li><p>'''Ответ:''' Это атака, при которой злоумышленник внедряет свой SQL-код в параметры запроса.</p></li>
<li><p>'''Пример с <code>Statement</code>:'''</p>
<syntaxhighlight lang="java">String userId = "105 OR 1=1"; // Ввод от злоумышленника
String sql = "SELECT * FROM users WHERE id = " + userId; // Получится "SELECT * FROM users WHERE id = 105 OR 1=1"
// Запрос вернёт ВСЕХ пользователей, так как 1=1 всегда истинно.</syntaxhighlight></li>
<li><p>'''Как <code>PreparedStatement</code> защищает:'''</p>
<syntaxhighlight lang="java">String userId = "105 OR 1=1";
PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM users WHERE id = ?");
pstmt.setString(1, userId); // Драйвер обработает всю строку "105 OR 1=1" как единое значение для поля id, а не как часть SQL.</syntaxhighlight></li></ul>

'''Что такое <code>ResultSet</code> и <code>RowSet</code>?'''

* '''<code>ResultSet</code>:'''
** Представляет результат выполнения <code>SELECT</code> запроса в виде таблицы.
** По сути, это '''курсор''', который указывает на текущую строку данных. Изначально он находится перед первой строкой. Метод <code>next()</code> сдвигает курсор на следующую строку и возвращает <code>false</code>, когда строки заканчиваются.
** По умолчанию <code>ResultSet</code> '''“привязан” к <code>Connection</code>'''. Если вы закроете соединение, <code>ResultSet</code> станет недействительным.
** Он однонаправленный (только <code>next()</code>) и не обновляемый.
* '''<code>RowSet</code>:'''
** Это интерфейс, который расширяет <code>ResultSet</code>.
** Ключевое отличие — <code>RowSet</code> может быть '''“отсоединённым” (disconnected)'''. Он может загрузить все данные из <code>ResultSet</code> в память, после чего соединение с БД можно закрыть. <code>RowSet</code> продолжит работать.
** Является полноценным JavaBean: его можно сериализовать, передавать по сети.
** Может быть прокручиваемым (scrolling) и обновляемым.
** Популярные реализации: <code>CachedRowSet</code> (отсоединённый), <code>JdbcRowSet</code> (присоединённый).


-----

<span id="раздел-6.-шаблоны-проектирования-design-patterns"></span>
=== Раздел 6. Шаблоны проектирования (Design Patterns) ===

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

* '''Singleton (Одиночка):'''
** '''Цель:''' Гарантировать, что у класса есть только один экземпляр, и предоставить глобальную точку доступа к нему.
** '''Связь с темами:''' Может использоваться для <code>DriverManager</code> (хотя он и так статический), для пула потоков, если он должен быть один на всё приложение, или для фабрики соединений.
** '''Вопрос на засыпку:''' Как сделать Singleton потокобезопасным? (Ответ: <code>synchronized</code> на методе <code>getInstance()</code>, double-checked locking с <code>volatile</code> переменной, через <code>Enum</code>, через статический инициализатор).
* '''Factory Method (Фабричный метод):'''
** '''Цель:''' Определяет интерфейс для создания объекта, но позволяет подклассам решать, какой класс инстанцировать.
** '''Связь с темами:''' Класс <code>Executors</code> использует фабричные методы (<code>newFixedThreadPool</code> и т.д.) для создания различных реализаций <code>ExecutorService</code>.
* '''Producer-Consumer (Производитель-Потребитель):'''
** '''Цель:''' Разделить работу между потоками, которые создают данные/задачи (производители), и потоками, которые их обрабатывают (потребители).
** '''Связь с темами:''' Это фундаментальный паттерн многопоточности. Идеально реализуется с помощью <code>BlockingQueue</code>. Производители вызывают <code>queue.put()</code>, потребители — <code>queue.take()</code>.
* '''Template Method (Шаблонный метод):'''
** '''Цель:''' Определяет “скелет” алгоритма в методе, оставляя реализацию некоторых шагов подклассам.
** '''Связь с темами:''' Весь процесс работы с JDBC — это классический шаблонный метод:
**# Получить соединение (может меняться).
**# Создать запрос (может меняться).
**# Выполнить запрос.
**# Обработать результат (может меняться).
**# Закрыть соединение. Фреймворки вроде Spring JDBC используют этот паттерн, чтобы скрыть от вас рутину (шаги 1, 5) и позволить сосредоточиться на главном (шаги 2, 4).
* '''Decorator (Декоратор):'''
** '''Цель:''' Динамически добавлять объекту новую функциональность, оборачивая его в другой объект.
** '''Связь с темами:''' Можно создать декоратор для <code>Connection</code>, который будет логировать все вызовы SQL-запросов, или для <code>ResultSet</code>, который будет кэшировать данные.
* '''DAO (Data Access Object):'''
** '''Цель:''' Абстрагировать и инкапсулировать все детали доступа к источнику данных. Приложение работает с простым интерфейсом DAO, а вся JDBC-логика (создание <code>Connection</code>, <code>PreparedStatement</code> и т.д.) скрыта внутри его реализации.
** '''Связь с темами:''' Это ключевой паттерн для работы с БД. Он позволяет отделить бизнес-логику от логики персистентности (сохранения данных).


[[Category:Программирование]]
[[Category:Программирование:Лабораторные]]