Потоки и каналы — бесплатный тест онлайн

Вопрос 1 из 25

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

Mutex<T> реализует Sync независимо от того, реализует ли T Send. Следовательно, поведение `std::thread` считалось бы одинаковым для всех допустимых типов. move closure захватывает используемые внешние значения по значению, но конкретный способ обращения внутри всё ещё определяет Fn/FnMut/FnOnce. Rc становится Send после помещения внутрь Mutex. Поэтому ошибочный сценарий вокруг «Замыкания с переносом move» не проверяли бы отдельно. Move-замыкание всегда клонирует захваченные данные перед spawn. Ordering::Relaxed публикует все предыдущие обычные записи для другого потока. Тогда поведение «Замыкания с переносом move» при раннем выходе выводили бы из обычного пути.

Вопрос 2 из 25

Что исправить вокруг `std::thread`, чтобы граничный вход обрабатывался безопасно?

use std::thread;
let handle = thread::spawn(|| 6 * 7);
println!("{}", handle.join().unwrap());

Добавить короткий `sleep` перед `std::thread`, полагаясь на ожидаемый порядок планирования потоков. Сохранять JoinHandle и явно решать, где ждать поток и как обрабатывать панику; не терять handle, если завершение является частью операции. Удалить `join` или подтверждение завершения, чтобы основной поток не ожидал проблемную операцию `std::thread`. Не вызывать join: завершение main автоматически дождётся каждого созданного потока. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Вручную реализовать `Send` или `Sync` для оболочки вокруг `std::thread`, не доказывая потоковую безопасность данные этого фрагмента.

Вопрос 3 из 25

Какая правка выдержит ревью контракта «Замыкания с переносом move»?

use std::thread;
let data = vec![1, 2, 3];
let handle = thread::spawn(move || data.len());
println!("{}", handle.join().unwrap());

Вручную реализовать `Send` или `Sync` для оболочки вокруг `std::thread`, не доказывая потоковую безопасность данные этого фрагмента. Оставить неограниченный канал без backpressure, потому что send не блокирует производителя. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Удалить `join` или подтверждение завершения, чтобы основной поток не ожидал проблемную операцию `std::thread`. По этой логике отдельная проверка `len` на другом входе считалась бы лишней. Добавить короткий `sleep` перед `std::thread`, полагаясь на ожидаемый порядок планирования потоков. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Передать владение нужными данными через move; если они нужны и родителю, выбрать Arc, канал или осознанную копию, а не ссылку на локальную переменную.

Вопрос 4 из 25

Что должно войти в отрицательный тест механизма «Замыкания с переносом move»?

Poison Mutex доказывает повреждение данных и не допускает осмысленного восстановления. Контракт «Замыкания с переносом move» считался бы одинаковым при любом состоянии входа. Join двух потоков в любом порядке исключает взаимную блокировку внутри их работы. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Тогда поведение «Замыкания с переносом move» при раннем выходе выводили бы из обычного пути. Если тип компилируется с Arc, его внутренние операции автоматически свободны от логических гонок. Отмена родительской функции автоматически отменяет все spawned-потоки. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Тогда поведение «Замыкания с переносом move» при раннем выходе выводили бы из обычного пути. Ключевое слово move не гарантирует Send: захваченный Rc или другой!Send-тип всё равно не может пересечь границу thread::spawn.

Вопрос 5 из 25

Как устранить исходную ошибку, связанную с `std::sync::mpsc`?

use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
let message = String::from("done");
tx.send(message).unwrap();
println!("{}", rx.recv().unwrap());

Вручную реализовать `Send` или `Sync` для оболочки вокруг `std::sync::mpsc`, не доказывая потоковую безопасность данные этого фрагмента. Добавить короткий `sleep` перед `std::sync::mpsc`, полагаясь на ожидаемый порядок планирования потоков. Передавать сообщения с ясным владельцем и закрывать канал удалением всех Sender; не держать лишний tx, если получатель должен увидеть завершение. Удалить `join` или подтверждение завершения, чтобы основной поток не ожидал проблемную операцию `std::sync::mpsc`. Игнорировать ошибку recv как временную и повторять чтение после закрытия всех отправителей. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 6 из 25

На какое правило следует опираться при ревью кода по теме «Тестирование и инструменты Cargo» в контексте «Потоки и каналы»?

Детерминированный конкурентный тест управляет причинным порядком событий и наблюдает завершение каждого потока, иначе редкая паника может остаться незамеченной. Порядок сообщений разных отправителей определяется порядком создания потоков. Mutex<T> реализует Sync независимо от того, реализует ли T Send. Следовательно, поведение `channel_closes_after_last_sender` считалось бы одинаковым для всех допустимых типов. Ordering::Relaxed публикует все предыдущие обычные записи для другого потока. Следовательно, поведение `channel_closes_after_last_sender` считалось бы одинаковым для всех допустимых типов. Borrow checker исключает взаимные блокировки наряду с гонками данных. Из этого следовало бы, что иной порядок операций для «Тестирование и инструменты Cargo» ничего не меняет.

Вопрос 7 из 25

Как переработать участок с `channel_closes_after_last_sender`, сохранив требуемое поведение?

#[test]
fn channel_closes_after_last_sender() {
    let (tx, rx) = std::sync::mpsc::channel::<u8>();
    let tx2 = tx.clone();
    drop(tx);
    drop(tx2);
    assert!(rx.recv().is_err());
}

Удалить `join` или подтверждение завершения, чтобы основной поток не ожидал проблемную операцию `channel_closes_after_last_sender`. Вручную реализовать `Send` или `Sync` для оболочки вокруг `channel_closes_after_last_sender`, не доказывая потоковую безопасность данные этого фрагмента. Не вызывать join: завершение main автоматически дождётся каждого созданного потока. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Добавить короткий `sleep` перед `channel_closes_after_last_sender`, полагаясь на ожидаемый порядок планирования потоков. Для потоков синхронизировать фазы Barrier или каналами, проверять join и тайм-ауты; sleep использовать только как верхнюю страховку, не как доказательство порядка.

Вопрос 8 из 25

Как правильно прочитать результат диагностического сценария `recv`?

let tx2 = tx.clone();
drop(tx);
drop(tx2);
assert!(rx.recv().is_err());

После успешного запуска основной ветви отдельные проверки ошибки, отмены и повторного вызова становятся избыточными. Следовательно, для `clone` не понадобилось бы явное предусловие. Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный сценарий вокруг `recv` при таком толковании уже не требуется. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. После удаления всех Sender recv возвращает ошибку отключения, что можно использовать как естественный сигнал конца потока сообщений.

Вопрос 9 из 25

Какой край контракта «Тестирование и инструменты Cargo» чаще всего остаётся незамеченным в контексте «Потоки и каналы»?

Обычные тесты не перебирают все планировки; критические атомарные протоколы дополнительно проверяют loom-подобным моделированием или специализированным анализом. Один успешный запуск подтверждает порядок планирования и сообщений для всех машин. Контракт «Тестирование и инструменты Cargo» считался бы одинаковым при любом состоянии входа. Если тип компилируется с Arc, его внутренние операции автоматически свободны от логических гонок. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Из этого следовало бы, что иной порядок операций для «Тестирование и инструменты Cargo» ничего не меняет. Удаление последнего sender можно не проверять: recv всегда имеет тайм-аут по умолчанию. Проверку ошибки для «Тестирование и инструменты Cargo» при таком подходе заменили бы успешным примером. Join двух потоков в любом порядке исключает взаимную блокировку внутри их работы. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Тогда поведение «Тестирование и инструменты Cargo» при раннем выходе выводили бы из обычного пути.

Вопрос 10 из 25

Какой вывод о выполнении `std::thread` подтверждает код?

use std::thread;
let handle = thread::spawn(|| 6 * 7);
println!("{}", handle.join().unwrap());

Код не пройдёт проверку: join возвращает результат завершившегося потока. Проверка типов пропустит этот путь: thread::spawn автоматически заимствует локальные данные до завершения родительской функции. Такая запись допустима, так как отсоединённый поток обязан завершиться до завершения процесса. Код компилируется, но взаимная блокировка автоматически обнаруживается и один поток отменяется. Код печатает 42: spawn запускает замыкание в новом потоке, а join ждёт завершения и возвращает его результат.

Вопрос 11 из 25

Что произойдёт после операции `std::sync::mpsc`?

use std::sync::mpsc;
let (tx, rx) = mpsc::channel();
let message = String::from("done");
tx.send(message).unwrap();
println!("{}", rx.recv().unwrap());

Код печатает done: send копирует String в канал, а recv передаёт владение получателю. Фрагмент не соберётся: join возвращает результат завершившегося потока. Код компилируется, но recv выбирает сообщение по глобальному времени отправки всех потоков. Код печатает done: send перемещает String в канал, а recv передаёт владение получателю. Код не пройдёт проверку: канал закрывается после удаления всех отправителей.

Вопрос 12 из 25

Какой эксплуатационный край отличает контракт «Потоки thread» от удачного примера?

Отмена родительской функции автоматически отменяет все spawned-потоки. Join двух потоков в любом порядке исключает взаимную блокировку внутри их работы. Тогда различия между обычным и граничным случаем для «Потоки thread» исчезли бы. Удаление JoinHandle отсоединяет поток и не останавливает его; процесс может завершиться раньше незавершённой фоновой работы. Удаление последнего sender можно не проверять: recv всегда имеет тайм-аут по умолчанию. Если тип компилируется с Arc, его внутренние операции автоматически свободны от логических гонок. Следовательно, для «Потоки thread» не понадобилось бы явное предусловие.

Вопрос 13 из 25

Какой путь выполнения выберет Rust после `std::thread`?

use std::thread;
let data = vec![1, 2, 3];
let handle = thread::spawn(move || data.len());
println!("{}", handle.join().unwrap());

Код печатает 3: move переносит Vec в окружение замыкания, удовлетворяя требованию независимости spawned-потока от текущего стека. Rust не примет такую запись, поскольку join возвращает результат завершившегося потока. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Ошибка возникнет на этапе компиляции: arc клонируется перед spawn. До последней строки и наблюдаемого результата программа при таком разборе не доходит. Rust не примет такую запись, поскольку тип не реализует Send из-за внутреннего Rc. До последней строки и наблюдаемого результата программа при таком разборе не доходит. До выполнения код дойдёт без ошибки компиляции, поскольку rc становится Send после помещения внутрь Mutex. Поэтому ошибочный сценарий вокруг `len` не проверяли бы отдельно.

Вопрос 14 из 25

Как правильно прочитать результат диагностического сценария `std::rc::Rc::new`?

let local = std::rc::Rc::new(1);
// std::thread::spawn(move || println!("{local}"));

Нормальный результат на одном входе позволяет распространить тот же вывод на отмену и частичное выполнение. Из этого следовало бы, что иной порядок операций для `std::rc` ничего не меняет. Отсутствие сообщения инструмента означает, что опасная ветвь была выполнена и признана корректной. Дополнительный сценарий вокруг `std::rc::Rc::new` при таком толковании уже не требуется. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `std::rc::Rc::new` при таком толковании уже не требуется. Раскомментированный spawn не компилируется, потому что Rc не реализует Send, несмотря на захват move. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно.

Вопрос 15 из 25

Какой граничный случай важнее всего учесть для механизма «Каналы mpsc»?

Неограниченная очередь не создаёт риска памяти, поскольку сообщения обрабатываются теми же потоками. В результате «Каналы mpsc» считали бы безопасным и на путях, которых пример не выполняет. recv блокируется до сообщения или закрытия всех отправителей; сохранённый клон Sender может вызвать вечное ожидание завершения. Join двух потоков в любом порядке исключает взаимную блокировку внутри их работы. По этой логике отдельная проверка «Каналы mpsc» на другом входе считалась бы лишней. Один успешный запуск подтверждает порядок планирования и сообщений для всех машин. Тогда поведение «Каналы mpsc» при раннем выходе выводили бы из обычного пути. Удаление последнего sender можно не проверять: recv всегда имеет тайм-аут по умолчанию.

Вопрос 16 из 25

Как правильно прочитать результат диагностического сценария `channel_closes_after_last_sender`?

#[test]
fn channel_closes_after_last_sender() {
    let (tx, rx) = std::sync::mpsc::channel::<u8>();
    let tx2 = tx.clone();
    drop(tx);
    drop(tx2);
    assert!(rx.recv().is_err());
}

Код компилируется, но recv выбирает сообщение по глобальному времени отправки всех потоков. Поэтому ошибочный сценарий вокруг `channel_closes_after_last_sender` не проверяли бы отдельно. Тест детерминированно проверяет протокол закрытия канала без sleep и гонки по времени. Этот фрагмент будет отклонён: arc клонируется перед spawn. До последней строки и наблюдаемого результата программа при таком разборе не доходит. До выполнения код дойдёт без ошибки компиляции, поскольку порядок сообщений разных отправителей определяется порядком создания потоков. Проверка типов завершится ошибкой: join возвращает результат завершившегося потока.

Вопрос 17 из 25

Как Rust выполнит этот фрагмент о механизме «Разделяемое состояние»?

use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0));
let mut handles = Vec::new();
for _ in 0..4 {
    let c = Arc::clone(&counter);
    handles.push(thread::spawn(move || *c.lock().unwrap() += 1));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());

Код считается допустимым, потому что sync означает, что значение можно перемещать между потоками, а Send — делиться ссылками. Контракт `push` считался бы одинаковым при любом состоянии входа. Сборка пройдёт, поскольку атомарная операция Relaxed устанавливает общий порядок всех обычных записей. Код компилируется, но relaxed-атомики синхронизируют все соседние неатомарные данные. Код печатает 4: Arc делит владение Mutex, а каждая блокировка сериализует увеличение счётчика. Код пройдёт проверку компилятора: rc становится Send после помещения внутрь Mutex.

Вопрос 18 из 25

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

Poison Mutex доказывает повреждение данных и не допускает осмысленного восстановления. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Relaxed подходит для публикации сложной структуры, если флаг имеет атомарный тип. Слишком крупная критическая секция снижает параллелизм, а слишком мелкая может разорвать инвариант между несколькими операциями. Join двух потоков в любом порядке исключает взаимную блокировку внутри их работы. Документация и тип результата тогда могут не оговаривать частичное выполнение или раннее завершение. Следовательно, для «Разделяемое состояние» не понадобилось бы явное предусловие. Неограниченная очередь не создаёт риска памяти, поскольку сообщения обрабатываются теми же потоками. Такое рассуждение переносило бы вывод о «Разделяемое состояние» на неисполненную ветвь.

Вопрос 19 из 25

Что нужно пересмотреть в использовании `std::sync::`, чтобы код стал корректным?

use std::sync::{Arc, Mutex};
use std::thread;
let counter = Arc::new(Mutex::new(0));
let mut handles = Vec::new();
for _ in 0..4 {
    let c = Arc::clone(&counter);
    handles.push(thread::spawn(move || *c.lock().unwrap() += 1));
}
for h in handles { h.join().unwrap(); }
println!("{}", *counter.lock().unwrap());

Вручную реализовать `Send` или `Sync` для оболочки вокруг `std::sync`, не доказывая потоковую безопасность данные этого фрагмента. Добавить короткий `sleep` перед `std::sync`, полагаясь на ожидаемый порядок планирования потоков. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Добавить sleep между операциями потоков и считать порядок выполнения закреплённым. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым. Проверку ошибки для `push` при таком подходе заменили бы успешным примером. Для простого числового счётчика оценить атомик; для составного инварианта держать связанные поля под одной блокировкой и фиксировать порядок нескольких locks. Удалить `join` или подтверждение завершения, чтобы основной поток не ожидал проблемную операцию `std::sync`. Сигнатура при этом почти не меняется, однако исходное предусловие остаётся скрытым.

Вопрос 20 из 25

Как сформулировать контракт механизма «Потоки thread» без привязки к именам переменных?

Поток, чей JoinHandle удалён, отменяется и освобождает все ресурсы немедленно. В результате «Потоки thread» считали бы безопасным и на путях, которых пример не выполняет. Move-замыкание всегда клонирует захваченные данные перед spawn. Thread::spawn автоматически заимствует локальные данные до завершения родительской функции. Такое рассуждение переносило бы вывод о «Потоки thread» на неисполненную ветвь. thread::spawn требует замыкание и результат с lifetime static и подходящим Send, потому что поток может жить дольше текущего стека. Отсоединённый поток обязан завершиться до завершения процесса. По этой логике отдельная проверка «Потоки thread» на другом входе считалась бы лишней.

Вопрос 21 из 25

Какой вывод о механизме «Каналы mpsc» соответствует модели Rust?

Mutex<T> реализует Sync независимо от того, реализует ли T Send. Следовательно, поведение `std::sync::mpsc` считалось бы одинаковым для всех допустимых типов. Порядок сообщений от разных отправителей mpsc является глобально детерминированным. Следовательно, поведение `std::sync::mpsc` считалось бы одинаковым для всех допустимых типов. Порядок сообщений разных отправителей определяется порядком создания потоков. Следовательно, поведение `std::sync::mpsc` считалось бы одинаковым для всех допустимых типов. Стандартный mpsc-канал поддерживает много отправителей и одного получателя; отправленное значение перемещается и больше не доступно отправителю. Закрытый канал возвращает пустое сообщение и остаётся пригодным для ожидания новых отправителей. Контракт «Каналы mpsc» считался бы одинаковым при любом состоянии входа.

Вопрос 22 из 25

На какую часть контракта распространяется проверка `std::thread::spawn`?

let handle = std::thread::spawn(|| panic!("worker failed"));
assert!(handle.join().is_err());

Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `std::thread::spawn` при таком толковании уже не требуется. После успешного запуска основной ветви отдельные проверки ошибки, отмены и повторного вызова становятся избыточными. Такое рассуждение переносило бы вывод о `join` на неисполненную ветвь. Совпадение полного текста диагностики является главным и стабильным контрактом этой проверки. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Паника рабочего потока не автоматически паникует родительский: join возвращает Err с payload, который нужно обработать.

Вопрос 23 из 25

На какое правило следует опираться при ревью кода по теме «Разделяемое состояние»?

Send означает безопасный общий доступ по &T, а Sync — безопасное перемещение T между потоками. Такое рассуждение переносило бы вывод о «Разделяемое состояние» на неисполненную ветвь. Sync означает, что значение можно перемещать между потоками, а Send — делиться ссылками. Тогда различия между обычным и граничным случаем для «Разделяемое состояние» исчезли бы. Arc<Mutex<T>> разделяет владение между потоками и обеспечивает исключительный доступ к T, но не предотвращает deadlock из-за порядка блокировок. Borrow checker исключает взаимные блокировки наряду с гонками данных. Поэтому ошибочный сценарий вокруг «Разделяемое состояние» не проверяли бы отдельно. Атомарная операция Relaxed устанавливает общий порядок всех обычных записей. В результате «Разделяемое состояние» считали бы безопасным и на путях, которых пример не выполняет.

Вопрос 24 из 25

Что показывает `channel_closes_after_last_sender` применительно к механизму «Тестирование и инструменты Cargo»?

#[test]
fn channel_closes_after_last_sender() {
    let (tx, rx) = std::sync::mpsc::channel::<u8>();
    let tx2 = tx.clone();
    drop(tx);
    drop(tx2);
    assert!(rx.recv().is_err());
}

# cargo test channel_closes_after_last_sender -- --exact
# cargo test -- --test-threads=1  # только для изоляции глобального состояния, не для исправления гонок

Достаточно убедиться, что пример компилируется; наблюдаемое поведение отдельной проверки не требует. Из этого следовало бы, что иной порядок операций для `channel_closes_after_last_sender` ничего не меняет. Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Успешного основного сценария достаточно; отмену, частичное завершение и повторный вход отдельно проверять не нужно. Однопоточный запуск тестов уменьшает внешнее взаимное влияние, но не делает внутренние рабочие потоки последовательными и не устраняет дефект синхронизации. Раз тест прошёл, производительность решения тоже можно считать подтверждённой.

Вопрос 25 из 25

Как следует интерпретировать результат проверки `std::sync::atomic::`?

use std::sync::atomic::{AtomicUsize, Ordering};
let counter = AtomicUsize::new(0);
counter.fetch_add(1, Ordering::Relaxed);
assert_eq!(counter.load(Ordering::Relaxed), 1);

Relaxed подходит для независимого статистического счётчика без синхронизации других данных; он не создаёт порядок для соседней памяти. Успешный запуск подтверждает корректность не только этого пути, но и остальных ветвей программы. Диагностика инструмента сама однозначно подсказывает безопасное исправление, поэтому разбирать контракт отдельно не нужно. Раз тест прошёл, производительность решения тоже можно считать подтверждённой. Дополнительный сценарий вокруг `std::sync::atomic::` при таком толковании уже не требуется. Если сценарий проходит в debug-сборке, в release и на другой целевой платформе результат будет тем же. Дополнительный сценарий вокруг `std::sync::atomic::` при таком толковании уже не требуется.