Конкурентность и async

В коде поток получает собственное владение Rc<Mutex<i32>>, но компилятор всё равно отклоняет запуск. Объясните, какой механизм делает такую передачу недопустимой.

use std::{rc::Rc, sync::Mutex, thread};

fn main() {
    let counter = Rc::new(Mutex::new(0));
    let worker_counter = Rc::clone(&counter);

    thread::spawn(move || {
        *worker_counter.lock().unwrap() += 1;
    }).join().unwrap();
}

Разберите ошибку в пользовательском future: почему runtime не сможет гарантированно продолжить выполнение задачи после первой проверки?

После запуска потока компилятор отклоняет этот код. Какое ограничение времени жизни нарушено захваченным значением?

use std::thread;

fn main() {
    let message = String::from("готово");
    let handle = thread::spawn(|| {
        println!("{message}");
    });
    handle.join().unwrap();
}

В коде ниже компилятор отвергает создание Pin<&mut F>. Какое свойство async-future делает закрепление в памяти необходимым перед передачей future исполнителю?

use std::future::Future;
use std::pin::Pin;

async fn task() {
    let text = String::from("data");
    async {}.await;
    println!("{text}");
}

fn pollable<F: Future>(mut future: F) {
    let pinned = Pin::new(&mut future);
    let _ = pinned;
}

fn main() {
    pollable(task());
}

Что происходит с async-операцией в Rust, когда её future уничтожают до завершения?

Разберите последствия выполнения блокирующей синхронной операции внутри async-задачи однопоточного runtime Rust.

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

В практической ситуации производитель отправляет сообщения быстрее потребителя: как ограниченный async-канал применяет обратное давление?

Как async runtime приводит созданный future к выполнению?

Объясните механизм: почему async-задача с несинхронным состоянием между точками ожидания может быть отклонена многопоточным runtime?