Структура LocalSet

Возвращает новый набор локальных задач.

Входит в контекст этого LocalSet.

Метод spawn_local запускает задачи в LocalSet, в контексте которого вы находитесь.

Запускает задачу !Send в наборе локальных задач.

Гарантируется, что эта задача будет выполняться в текущем потоке.

В отличие от свободной функции spawn_local, этот метод можно использовать для запуска локальных задач, когда LocalSet не запущен. Переданный future начнёт выполняться при следующем запуске LocalSet, даже если вы не ожидаете возвращённый JoinHandle.

Примеры

use tokio::task;

let local = task::LocalSet::new();

// Spawn a future on the local set. This future will be run when
// we call `run_until` to drive the task set.
local.spawn_local(async {
    // ...
});

// Run the local task set.
local.run_until(async move {
    // ...
}).await;

// When `run` finishes, we can spawn _more_ futures, which will
// run in subsequent calls to `run_until`.
local.spawn_local(async {
    // ...
});

local.run_until(async move {
    // ...
}).await;

Выполняет future до завершения в предоставленной среде выполнения, обслуживая в текущем потоке все локальные future, запущенные в этом наборе задач.

Этот метод выполняет переданный future в среде выполнения, блокируя выполнение до его завершения и возвращая полученный результат. Все задачи и таймеры, созданные future, будут выполняться в среде выполнения. Future также может вызвать spawn_local, чтобы spawn_local дополнительные локальные future в текущем потоке.

Этот метод нельзя вызывать из асинхронного контекста.

Панические завершения

Эта функция вызывает панику, если исполнитель достиг предельной нагрузки, если предоставленный future вызывает панику или если функция вызвана в контексте асинхронного выполнения.

Примечания

Поскольку эта функция внутри вызывает Runtime::block_on и обслуживает future из локального набора задач внутри этого вызова до block_on, локальные future не могут использовать блокировку на месте. Если из локальной задачи необходимо выполнить блокирующий вызов, вместо этого можно использовать API spawn_blocking.

Например, это вызовет панику:

use tokio::runtime::Runtime;
use tokio::task;

let rt  = Runtime::new().unwrap();
let local = task::LocalSet::new();
local.block_on(&rt, async {
    let join = task::spawn_local(async {
        let blocking_result = task::block_in_place(|| {
            // ...
        });
        // ...
    });
    join.await.unwrap();
})

Однако это не вызовет панику:

use tokio::runtime::Runtime;
use tokio::task;

let rt  = Runtime::new().unwrap();
let local = task::LocalSet::new();
local.block_on(&rt, async {
    let join = task::spawn_local(async {
        let blocking_result = task::spawn_blocking(|| {
            // ...
        }).await;
        // ...
    });
    join.await.unwrap();
})

Выполняет future до завершения в локальном наборе и возвращает его результат.

Этот метод возвращает future, который выполняет переданный future с локальным набором, позволяя ему вызывать spawn_local для запуска дополнительных !Send future. Все локальные future, запущенные в локальном наборе, будут выполняться в фоновом режиме, пока не завершится future, переданный в run_until. Когда future, переданный в run_until, завершится, все незавершённые локальные future останутся в локальном наборе и будут выполняться при последующих вызовах run_until или при ожидании самого локального набора.

Безопасность при отмене

Этот метод безопасен при отмене, если future безопасен при отмене.

Примеры

use tokio::task;

task::LocalSet::new().run_until(async {
    task::spawn_local(async move {
        // ...
    }).await.unwrap();
    // ...
}).await;

Возвращает Id текущей среды выполнения LocalSet.

Примеры

use tokio::task;

let local_set = task::LocalSet::new();
println!("Local set id: {}", local_set.id());

Настраивает поведение LocalSet при необработанной панике в запущенной задаче.

По умолчанию необработанная паника (то есть паника, не перехваченная с помощью std::panic::catch_unwind) не влияет на выполнение LocalSet. Значение ошибки паники передаётся в JoinHandle задачи, а все остальные запущенные задачи продолжают выполняться.

Параметр unhandled_panic позволяет настроить это поведение.

• UnhandledPanic::Ignore — поведение по умолчанию. Паники в запущенных задачах не влияют на выполнение LocalSet.
• UnhandledPanic::ShutdownRuntime заставит LocalSet немедленно завершить работу при панике в запущенной задаче, даже если её JoinHandle ещё не был удалён. Все остальные запущенные задачи немедленно завершатся, а последующие вызовы LocalSet::block_on и LocalSet::run_until вызовут панику.

Паники

Этот метод вызывает панику, если его вызвать после начала выполнения LocalSet.

Нестабильный API

Этот параметр в настоящее время является нестабильным, а его реализация не завершена. В будущем API может измениться или быть удалён. Подробнее см. tokio-rs/tokio#4516.

Примеры

В следующем примере показан LocalSet, настроенный на завершение работы при панике. Первая запущенная задача вызывает панику, в результате чего LocalSet завершает работу. Вторая запущенная задача не успевает выполниться. Вызов run_until вызовет панику, поскольку среда выполнения была принудительно остановлена.

use tokio::runtime::UnhandledPanic;

tokio::task::LocalSet::new()
    .unhandled_panic(UnhandledPanic::ShutdownRuntime)
    .run_until(async {
        tokio::task::spawn_local(async { panic!("boom"); });
        tokio::task::spawn_local(async {
            // This task never completes
        });

        // Do some work, but `run_until` will panic before it completes
    })
    .await;

Возвращает аргумент без изменений.

Вызывает U::from(self).

То есть это преобразование выполняет действие, выбранное реализацией From<T> for U.