Структура Task

Источник: Документация smol::Task

#![allow(unused)]
fn main() {
pub struct Task<T, M = ()> { /* private fields */ }
}

Запущенная задача.

Описание

Задачу Task можно ожидать (await) для получения результата ее фьючерса.

Удаление (dropping) задачи Task отменяет ее, что означает, что ее фьючерс больше не будет опрашиваться. Чтобы удалить дескриптор задачи без ее отмены, используйте вместо этого метод detach(). Для грациозной отмены задачи и ожидания ее полного уничтожения используйте метод cancel().

Важно: отмена задачи фактически пробуждает ее и перепланирует один последний раз. Затем исполнитель может уничтожить задачу, просто удалив ее Runnable или вызвав run().

Параметры типа

T - тип результата, возвращаемого задачей
M - тип метаданных (по умолчанию ())

Примеры

#![allow(unused)]
fn main() {
use smol::{future, Executor};
use std::thread;

let ex = Executor::new();

// Запускаем фьючерс в исполнителе.
let task = ex.spawn(async {
    println!("Hello from a task!");
    1 + 2
});

// Запускаем поток исполнителя.
thread::spawn(move || future::block_on(ex.run(future::pending::<()>())));

// Ожидаем результат задачи.
assert_eq!(future::block_on(task), 3);
}

Ожидание результата: Задачи можно ожидать через await для получения результата

Автоматическая отмена: Удаление задачи приводит к ее отмене

Грациозная отмена: Метод cancel() обеспечивает корректное завершение

Фоновое выполнение: detach() позволяет задаче работать в фоне

Основные методы

Метод	Сигнатура	Возвращаемый тип	Описание
`detach`	`pub fn detach(self)`	`()`	Отсоединяет задачу для фонового выполнения
`cancel`	`pub async fn cancel(self) -> Option<T>`	`Option<T>`	Отменяет задачу и ждет завершения
`fallible`	`pub fn fallible(self) -> FallibleTask<T, M>`	`FallibleTask<T, M>`	Преобразует в FallibleTask
`is_finished`	`pub fn is_finished(&self) -> bool`	`bool`	Проверяет завершена ли задача
`metadata`	`pub fn metadata(&self) -> &M`	`&M`	Возвращает метаданные задачи

Подробное описание методов

Управление выполнением

Метод	Назначение	Особенности	Пример использования
`detach`	Отсоединяет задачу	Задача продолжает работать в фоне	`task.detach()`
`cancel`	Грациозная отмена	Ждет завершения, возвращает результат	`task.cancel().await`
`fallible`	Создает fallible версию	Обрабатывает отмену через `None`	`task.fallible()`

Состояние и метаданные

Метод	Назначение	Примечания
`is_finished`	Проверка состояния	Может измениться сразу после вызова
`metadata`	Доступ к метаданным	По умолчанию `()`

Примеры использования

Базовое использование

#![allow(unused)]
fn main() {
use smol::{future, Executor};
use std::thread;

let ex = Executor::new();

// Запуск задачи в исполнителе
let task = ex.spawn(async {
    println!("Hello from a task!");
    1 + 2
});

// Ожидание результата
assert_eq!(future::block_on(task), 3);
}

Отсоединение задачи

#![allow(unused)]
fn main() {
use smol::{Executor, Timer};
use std::time::Duration;

let ex = Executor::new();

// Демон-задача
ex.spawn(async {
    loop {
        println!("I'm a daemon task looping forever.");
        Timer::after(Duration::from_secs(1)).await;
    }
})
.detach();
}

Грациозная отмена

#![allow(unused)]
fn main() {
use smol::{future, Executor, Timer};
use std::thread;
use std::time::Duration;

let ex = Executor::new();
let task = ex.spawn(async {
    loop {
        println!("You can still cancel me!");
        Timer::after(Duration::from_secs(1)).await;
    }
});

future::block_on(async {
    Timer::after(Duration::from_secs(3)).await;
    task.cancel().await; // Грациозная отмена
});
}

Реализации трейтов

Основные трейты

Трейт	Реализация	Назначение
`Future`	`impl<T, M> Future for Task<T, M>`	Ожидание результата задачи
`Debug`	`impl<T, M> Debug for Task<T, M>`	Отладочное представление
`Drop`	`impl<T, M> Drop for Task<T, M>`	Автоматическая отмена при удалении

Маркерные трейты

Трейт	Условия	Назначение
`Send`	`T: Send, M: Send + Sync`	Передача между потоками
`Sync`	`M: Send + Sync`	Разделение между потоками
`Unpin`	Всегда	Можно перемещать после закрепления
`UnwindSafe`	Всегда	Безопасность при панике
`RefUnwindSafe`	Всегда	Безопасность ссылок при панике
`Freeze`	Всегда	Может быть заморожено

Типы и зависимости

Параметры типа

Параметр	Ограничения	Назначение
`T`	Любой тип	Результат выполнения задачи
`M`	По умолчанию `()`	Метаданные задачи

Связанные типы

Тип	Назначение
`FallibleTask<T, M>`	Задача с обработкой отмены
`Output = T`	Тип результата для Future

Поведение при удалении

Действие	Результат	Альтернатива
`drop(task)`	Немедленная отмена	`task.detach()`
`task.cancel().await`	Грациозная отмена	-
`task.detach()`	Продолжение выполнения	-

Особенности многопоточности

is_finished() может изменить состояние сразу после вызова
Отмена задачи пробуждает ее для последнего выполнения
Исполнитель может уничтожить задачу через Runnable

Таблица сравнения методов отмены

Метод	Тип	Возвращает	Поведение
`drop()`	Синхронный	-	Немедленная отмена
`cancel().await`	Асинхронный	`Option<T>`	Грациозная отмена
`detach()`	Синхронный	-	Без отмены

Трейты Future

Реализация Future

Метод	Сигнатура	Назначение
`poll`	`fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<T>`	Опрос готовности результата
`Output`	`type Output = T`	Тип выходного значения

Безопасность

Send: Только если T: Send и M: Send + Sync
Sync: Только если M: Send + Sync
UnwindSafe: Всегда безопасно для размотки
Panic Safety: Отмена безопасна при панике

Keyboard shortcuts

DOCS.RS