Потоки выполнения и синхронизация — бесплатный тест онлайн

Вопрос 1 из 25

Какой инженерный компромисс характерен для темы «Тестирование и диагностика» в разделе «Потоки выполнения и синхронизация»?

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

Вопрос 2 из 25

Какое ограничение механизма «Видимость данных» нельзя упускать при работе с разделом «Потоки выполнения и синхронизация»?

volatile count++ всё ещё теряет обновления, поскольку чтение, сложение и запись — отдельные действия. synchronized static использует монитор Class-объекта и не совпадает с монитором экземпляра. Отсутствие сбоя в тысяче запусков не доказывает отсутствие гонки; полезны jcstress, анализ happens-before и профилирование. Один объект Thread нельзя запустить второй раз; повторный start даёт IllegalThreadStateException. ConcurrentHashMap не делает атомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация.

Вопрос 3 из 25

На какое правило следует опираться при разборе темы «Мониторы synchronized» в разделе «Потоки выполнения и синхронизация»?

Вызов start создаёт новый поток выполнения, а прямой run выполняется в текущем потоке. Конкурентные тесты должны координировать старт, повторять сценарий и проверять инвариант, не полагаясь на sleep как доказательство. synchronized обеспечивает взаимное исключение и отношение happens-before между освобождением и последующим захватом того же монитора. Гонка возникает, когда результат зависит от неконтролируемого порядка конкурентных доступов к общему изменяемому состоянию. Без happens-before поток может не увидеть изменение обычного поля; volatile даёт видимость и порядок, но не атомарность составной операции.

Вопрос 4 из 25

Какое утверждение о механизме «Видимость данных» верно в контексте раздела «Потоки выполнения и синхронизация»?

synchronized обеспечивает взаимное исключение и отношение happens-before между освобождением и последующим захватом того же монитора. Без happens-before поток может не увидеть изменение обычного поля; final даёт видимость и порядок, но не атомарность составной операции. Конкурентные тесты должны координировать старт, повторять сценарий и проверять инвариант, не полагаясь на sleep как доказательство. Atomic-классы дают атомарные операции над одним значением и compare-and-set, но не защищают произвольный составной инвариант. Без happens-before поток может не увидеть изменение обычного поля; volatile даёт видимость и порядок, но не атомарность составной операции.

Вопрос 5 из 25

Какой диагноз для кода по теме «Состояния гонки» в разделе «Потоки выполнения и синхронизация» будет точным?

class Counter { int value; void inc() { value++; } }
var c = new Counter();
// два потока вызывают c.inc() по миллиону раз

Рабочий поток формально может не завершиться, потому что поле stop не объявлено volatile и не читается под блокировкой. Thread.sleep(10) не гарантирует, что другой поток достиг нужной строки. Два потока могут прочитать одно value и записать одинаковый увеличенный результат, потеряв одно обновление. Код печатает имя main, потому что run вызван как обычный метод. Потоки синхронизируются на разных экземплярах, хотя меняют одно static-поле; итог может оказаться меньше 200000 из-за потерянных обновлений.

Вопрос 6 из 25

Что важно учитывать при применении механизма «Состояния гонки» из раздела «Потоки выполнения и синхронизация» в рабочем проекте?

Volatile хорош для независимого состояния и публикации, но инвариант нескольких полей требует блокировки или неизменяемого снимка. Удаление общего состояния часто лучше блокировки, но копирование и объединение могут увеличить память и задержку. Крупная критическая секция проще для корректности, но снижает параллелизм и увеличивает задержку ожидания. Атомарность по ключу снижает блокировки, но операции сразу над несколькими ключами требуют отдельного протокола. Детерминированная координация повышает шанс воспроизведения, но иногда меняет расписание и требует дополнения нагрузочным тестом.

Вопрос 7 из 25

Что важно учитывать при применении механизма «Видимость данных» из раздела «Потоки выполнения и синхронизация» в рабочем проекте?

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

Вопрос 8 из 25

В каком дополнительном сценарии вывод о теме «Потоки Thread» в разделе «Потоки выполнения и синхронизация» может оказаться неверным?

// Минимальный пример
var t = new Thread(() ->
    System.out.println(Thread.currentThread().getName()));
t.run();

Один объект Thread нельзя запустить первый раз; повторный start даёт IllegalThreadStateException. Во время перехода на летнее время локальное время может отсутствовать или встречаться дважды. Один объект Thread нельзя запустить второй раз; повторный start даёт IllegalThreadStateException. Один объект Thread нельзя запустить второй раз; повторный run даёт IllegalThreadStateException. Отсутствие сбоя в тысяче запусков не доказывает отсутствие гонки; полезны jcstress, анализ happens-before и профилирование.

Вопрос 9 из 25

Какая правка точнее всего устраняет причину проблемы по теме «Видимость данных» в разделе «Потоки выполнения и синхронизация»?

// Фрагмент на ревью
class Worker {
    boolean stop;
    void run() { while (!stop) { doWork(); } }
    void shutdown() { stop = true; }
}

Сделать флаг volatile, использовать interrupt или синхронизированный протокол остановки. Использовать CountDownLatch, CyclicBarrier или Phaser для воспроизводимого взаимного расположения действий. Вызвать start и при необходимости join для ожидания завершения. Использовать AtomicInteger.incrementAndGet, synchronized или локальное накопление с последующим объединением. Сделать флаг final, использовать interrupt или синхронизированный протокол остановки.

Вопрос 10 из 25

Какое правило Java действует для темы «Состояния гонки» в разделе «Потоки выполнения и синхронизация»?

Гонка возникает, когда результат зависит от неконтролируемого порядка конкурентных доступов к общему изменяемому состоянию. Без happens-before поток может не увидеть изменение обычного поля; volatile даёт видимость и порядок, но не атомарность составной операции. Конкурентные тесты должны координировать старт, повторять сценарий и проверять инвариант, не полагаясь на sleep как доказательство. ConcurrentHashMap поддерживает конкурентные операции и атомарные compute/merge для одного ключа. synchronized обеспечивает взаимное исключение и отношение happens-before между освобождением и последующим захватом того же монитора.

Вопрос 11 из 25

В каком дополнительном сценарии вывод о теме «Тестирование и диагностика» в разделе «Потоки выполнения и синхронизация» может оказаться неверным?

// ...
new Thread(() -> result.add(2)).start();
Thread.sleep(10);
System.out.println(result.size());

Один объект Thread нельзя запустить второй раз; повторный start даёт IllegalThreadStateException. ReentrantLock не гарантирует справедливость по умолчанию; fair-режим уменьшает голодание ценой пропускной способности. ConcurrentHashMap не делает атомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация. volatile count++ всё ещё теряет обновления, поскольку чтение, сложение и запись — отдельные действия. Отсутствие сбоя в тысяче запусков не доказывает отсутствие гонки; полезны jcstress, анализ happens-before и профилирование.

Вопрос 12 из 25

Что произойдёт с кодом по теме «Мониторы synchronized» в разделе «Потоки выполнения и синхронизация»?

class Counter {
    static int value;
    synchronized void inc() { value++; }
}
var a = new Counter();
var b = new Counter();
var t1 = new Thread(() -> { for (int i = 0; i < 100_000; i++) a.inc(); });
var t2 = new Thread(() -> { for (int i = 0; i < 100_000; i++) b.inc(); });
t1.start(); t2.start(); t1.join(); t2.join();
System.out.println(Counter.value);

Потоки синхронизируются на разных экземплярах, хотя меняют одно static-поле; итог может оказаться меньше 200000 из-за потерянных обновлений. Потоки синхронизируются на разных экземплярах, хотя меняют одно static-поле; итог может оказаться меньше 199999 из-за потерянных обновлений. Два потока могут прочитать одно value и записать одинаковый увеличенный результат, потеряв одно обновление. Потоки синхронизируются на разных экземплярах, хотя меняют одно static-поле; итог может оказаться меньше 200001 из-за потерянных обновлений. Рабочий поток формально может не завершиться, потому что поле stop не объявлено volatile и не читается под блокировкой.

Вопрос 13 из 25

Что произойдёт с кодом по теме «Тестирование и диагностика» в разделе «Потоки выполнения и синхронизация»?

var result = new java.util.ArrayList<Integer>();
new Thread(() -> result.add(1)).start();
new Thread(() -> result.add(2)).start();
Thread.sleep(10);
System.out.println(result.size());

Рабочий поток формально может не завершиться, потому что поле stop не объявлено volatile и не читается под блокировкой. Thread.sleep(11) не гарантирует, что другой поток достиг нужной строки. Код печатает имя main, потому что run вызван как обычный метод. Thread.sleep(9) не гарантирует, что другой поток достиг нужной строки. Thread.sleep(10) не гарантирует, что другой поток достиг нужной строки.

Вопрос 14 из 25

Какое изменение сделает код по теме «Потоки Thread» в разделе «Потоки выполнения и синхронизация» надёжнее?

// Фрагмент на ревью
var t = new Thread(() ->
    System.out.println(Thread.currentThread().getName()));
t.run();

Вызвать start и при необходимости join для ожидания завершения. Использовать thenCompose, когда функция запускает асинхронную операцию. Синхронизироваться на общем объекте, который действительно защищает общее состояние. Использовать CountDownLatch, CyclicBarrier или Phaser для воспроизводимого взаимного расположения действий. Вызвать run и при необходимости join для ожидания завершения.

Вопрос 15 из 25

Какое замечание о сопровождении или производительности темы «Мониторы synchronized» в разделе «Потоки выполнения и синхронизация» справедливо?

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

Вопрос 16 из 25

Что следует изменить в разделе «Потоки выполнения и синхронизация», чтобы сохранить замысел и соблюсти контракт «Состояния гонки»?

// Фрагмент на ревью
class Counter { int value; void inc() { value++; } }
var c = new Counter();
// два потока вызывают c.inc() по миллиону раз

Использовать AtomicInteger.incrementAndGet, volatile или локальное накопление с последующим объединением. Использовать CountDownLatch, CyclicBarrier или Phaser для воспроизводимого взаимного расположения действий. Сделать флаг volatile, использовать interrupt или синхронизированный протокол остановки. Использовать computeIfAbsent с короткой, не рекурсивной и безопасной функцией. Использовать AtomicInteger.incrementAndGet, synchronized или локальное накопление с последующим объединением.

Вопрос 17 из 25

Какой диагноз для кода по теме «Видимость данных» в разделе «Потоки выполнения и синхронизация» будет точным?

class Worker {
    boolean stop;
    void run() { while (!stop) { doWork(); } }
    void shutdown() { stop = true; }
}

После signal поток может проснуться, когда очередь снова пуста, и removeFirst завершится ошибкой. Рабочий поток формально может не завершиться, потому что поле stop не объявлено final и не читается под блокировкой. Два потока могут прочитать одно value и записать одинаковый увеличенный результат, потеряв одно обновление. Рабочий поток формально может не завершиться, потому что поле stop не объявлено volatile и не читается под блокировкой. Код печатает имя main, потому что run вызван как обычный метод.

Вопрос 18 из 25

Что произойдёт с кодом по теме «Потоки Thread» в разделе «Потоки выполнения и синхронизация»?

var t = new Thread(() ->
    System.out.println(Thread.currentThread().getName()));
t.run();

Код печатает имя main, потому что run вызван как обычный метод. Код печатает имя main, потому что start вызван как обычный метод. Код печатает имя нового потока, потому что run вызван как обычный метод. Рабочий поток формально может не завершиться, потому что поле stop не объявлено volatile и не читается под блокировкой. Thread.sleep(10) не гарантирует, что другой поток достиг нужной строки.

Вопрос 19 из 25

Что нужно отдельно проверить на границе контракта «Состояния гонки» в разделе «Потоки выполнения и синхронизация»?

// Минимальный пример
class Counter { int value; void inc() { value++; } }
var c = new Counter();
// два потока вызывают c.inc() по миллиону раз

synchronized static использует монитор Class-объекта и не совпадает с монитором экземпляра. ConcurrentHashMap не делает атомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация. ConcurrentTreeMap не делает атомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация. Итераторы слабосогласованные: они не выбрасывают ConcurrentModificationException и могут отражать лишь часть текущих изменений. ConcurrentHashMap не делает неатомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация.

Вопрос 20 из 25

Какая правка точнее всего устраняет причину проблемы по теме «Мониторы synchronized» в разделе «Потоки выполнения и синхронизация»?

// Фрагмент на ревью
class Counter {
    static int value;
    synchronized void inc() { value++; }
}
var a = new Counter();
var b = new Counter();
var t1 = new Thread(() -> { for (int i = 0; i < 100_000; i++) a.inc(); });
var t2 = new Thread(() -> { for (int i = 0; i < 100_000; i++) b.inc(); });
t1.start(); t2.start(); t1.join(); t2.join();
System.out.println(Counter.value);

Синхронизироваться на общем объекте, который действительно защищает общее состояние. Использовать AtomicInteger.incrementAndGet, synchronized или локальное накопление с последующим объединением. Проверять события JFR и обновлять рекомендации с учётом версии JDK, а не механически заменять каждый synchronized на Lock. Использовать CountDownLatch, CyclicBarrier или Phaser для воспроизводимого взаимного расположения действий. Сделать флаг volatile, использовать interrupt или синхронизированный протокол остановки.

Вопрос 21 из 25

Какое замечание о сопровождении или производительности темы «Потоки Thread» в разделе «Потоки выполнения и синхронизация» справедливо?

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

Вопрос 22 из 25

Какое утверждение о механизме «Потоки Thread» верно в контексте раздела «Потоки выполнения и синхронизация»?

Вызов start создаёт новый поток выполнения, а прямой run выполняется в новом потоке. Вызов start не создаёт новый поток выполнения, а прямой run выполняется в текущем потоке. Вызов start создаёт новый поток выполнения, а прямой run выполняется в текущем потоке. Тесты времени должны управлять Clock, зоной и локалью, а также покрывать переходы DST и границы периода. Condition.await надо вызывать в цикле, повторно проверяющем предикат, потому что возможны ложные пробуждения и конкуренция.

Вопрос 23 из 25

Что нужно отдельно проверить на границе контракта «Мониторы synchronized» в разделе «Потоки выполнения и синхронизация»?

// ...
var t2 = new Thread(() -> { for (int i = 0; i < 100_000; i++) b.inc(); });
t1.start(); t2.start(); t1.join(); t2.join();
System.out.println(Counter.value);

ConcurrentHashMap не делает атомарной последовательность get затем put; нужна compute/merge или внешняя синхронизация. volatile static использует монитор Class-объекта и не совпадает с монитором экземпляра. Закрепление не делает результат некорректным; оно влияет на масштабирование и доступность потоков-носителей. volatile count++ всё ещё теряет обновления, поскольку чтение, сложение и запись — отдельные действия. synchronized static использует монитор Class-объекта и не совпадает с монитором экземпляра.

Вопрос 24 из 25

Что следует изменить в разделе «Потоки выполнения и синхронизация», чтобы сохранить замысел и соблюсти контракт «Тестирование и диагностика»?

// Фрагмент на ревью
var result = new java.util.ArrayList<Integer>();
new Thread(() -> result.add(1)).start();
new Thread(() -> result.add(2)).start();
Thread.sleep(10);
System.out.println(result.size());

Передать отдельный исполнитель задач и завершать его в finally; для ограничений времени использовать управляемые средства. Сделать флаг volatile, использовать interrupt или синхронизированный протокол остановки. Использовать AtomicInteger.incrementAndGet, synchronized или локальное накопление с последующим объединением. Синхронизироваться на общем объекте, который действительно защищает общее состояние. Использовать CountDownLatch, CyclicBarrier или Phaser для воспроизводимого взаимного расположения действий.

Вопрос 25 из 25

Какое правило Java действует для темы «Тестирование и диагностика» в разделе «Потоки выполнения и синхронизация»?

synchronized обеспечивает взаимное исключение и отношение happens-before между освобождением и последующим захватом того же монитора. Гонка возникает, когда результат зависит от неконтролируемого порядка конкурентных доступов к общему изменяемому состоянию. Конкурентные тесты должны координировать старт, повторять сценарий и проверять инвариант, не полагаясь на sleep как доказательство. Без happens-before поток может не увидеть изменение обычного поля; volatile даёт видимость и порядок, но не атомарность составной операции. Конкуренция за блокировку, длина критической секции и ложное совместное использование памяти важнее названия примитива синхронизации.