Программирование Rust

В Tokio уничтожили JoinHandle незавершённой задачи: продолжит ли задача выполняться?

В многопоточном Tokio одна задача выполняет длинные серии быстрых операций внутри одного poll; как кооперативный бюджет предотвращает голодание остальных задач?

В практической ситуации async-функцию вызвали, но полученный future не передали runtime и не ожидали: когда начнётся тело функции?

При росте числа CPU-bound задач, переданных в spawn_blocking, почему их выполнение не становится неограниченно параллельным?

В контейнере нужно хранить несколько async-задач с разными конкретными типами future. Какой приём Rust позволяет представить их единым типом?

Сравните семантику Future и Stream: почему одно ожидание Future получает итоговое значение, тогда как Stream нужно опрашивать многократно?

Задача Tokio завершилась паникой: каким образом эта паника достигает вызывающей async-задачи через JoinHandle?

Как OnceLock<T> безопасно публикует лениво созданное значение для нескольких потоков?

В Tokio несколько задач одновременно ждут один async mutex: гарантирован ли порядок FIFO выдачи блокировки?

Каким способом многопоточный async runtime запускает future, которая не реализует Send, без передачи её между рабочими потоками?

Функция передаёт заимствованные данные в задачу многопоточного async runtime, которая может завершиться позже самой функции: какое требование к времени жизни future предотвращает висячую ссылку?

В lock-free стеке CAS видит указатель A после последовательности A→B→A: какую ошибку проверки это создаёт?

После уничтожения runtime Tokio что произойдёт с незавершённой async-задачей, созданной в нём?

В однопоточном runtime две задачи используют yield_now().await. Разберите, гарантирует ли этот вызов строгую очерёдность их выполнения.

use tokio::task::yield_now;

#[tokio::main(flavor = "current_thread")]
async fn main() {
    tokio::join!(worker("A"), worker("B"));
}

async fn worker(name: &'static str) {
    for i in 0..3 {
        println!("{name}: {i}");
        yield_now().await;
    }
}

Когда RwLock<T> в Rust может проиграть Mutex<T> на преимущественно читающей нагрузке?

Гарантируют ли маркеры Send и Sync отсутствие логических гонок в многопоточном Rust?

Поток ожидает условие через Condvar: почему пробуждение не доказывает, что условие уже выполнено?

Какой инвариант должен соблюдать многопоточный async runtime при планировании одной future?

В async-коде нужно определить, является ли значение из thread_local! локальным для задачи. Какой результат допустим после передачи задачи между рабочими потоками?

use std::cell::Cell;
use tokio::task::yield_now;

thread_local! {
    static POLLS: Cell<u32> = Cell::new(0);
}

#[tokio::main(flavor = "multi_thread", worker_threads = 2)]
async fn main() {
    let task = tokio::spawn(async {
        POLLS.with(|p| p.set(p.get() + 1));
        yield_now().await;
        POLLS.with(|p| p.get())
    });
    println!("{}", task.await.unwrap());
}

В системе несколько потоков клонируют Sender одного канала std::sync::mpsc: почему сообщения распределяются между потребителями, а не рассылаются каждому из них?