Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Применение конкурентности с async

В этом разделе мы применим async к некоторым из тех же задач конкурентности, которые мы решали с потоками в главе 16. Поскольку мы уже говорили о многих ключевых идеях там, в этом разделе мы сосредоточимся на том, что отличается между потоками и фьючерсами.

Во многих случаях API для работы с конкурентностью с помощью async очень похожи на API для работы с потоками. В других случаях они оказываются довольно разными. Даже когда API выглядят похожими между потоками и async, они часто ведут себя по-разному — и почти всегда имеют разные характеристики производительности.

Создание новой задачи с помощью spawn_task

Первая операция, которую мы рассмотрели в разделе «Создание нового потока с помощью spawn» в главе 16, была подсчёт на двух отдельных потоках. Давайте сделаем то же самое с помощью async. Крейт trpl предоставляет функцию spawn_task, которая выглядит очень похоже на API thread::spawn, и функцию sleep, которая является async-версией API thread::sleep. Мы можем использовать их вместе, чтобы реализовать пример подсчёта, как показано в листинге 17-6.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        trpl::spawn_task(async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        });

        for i in 1..5 {
            println!("hi number {i} from the second task!");
            trpl::sleep(Duration::from_millis(500)).await;
        }
    });
}
Листинг 17-6: Создание новой задачи для печати одного, пока главная задача печатает другое

В качестве отправной точки мы настроили нашу функцию main с помощью trpl::block_on, чтобы наша функция верхнего уровня могла быть async.

Примечание: С этого момента в главе каждый пример будет включать этот же самый оборачивающий код с trpl::block_on в main, поэтому мы часто будем его пропускать, как мы это делаем с main. Не забудьте включить его в свой код!

Затем мы пишем два цикла внутри этого блока, каждый содержит вызов trpl::sleep, который ждёт полсекунды (500 миллисекунд) перед отправкой следующего сообщения. Мы помещаем один цикл в тело trpl::spawn_task, а другой — в цикл for верхнего уровня. Мы также добавляем await после вызовов sleep.

Этот код ведёт себя аналогично реализации на потоках — включая тот факт, что вы можете увидеть сообщения в другом порядке в вашем собственном терминале при запуске:

hi number 1 from the second task!
hi number 1 from the first task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!

Эта версия останавливается, как только цикл for в теле главного async-блока завершается, потому что задача, порождённая spawn_task, завершается при завершении функции main. Если вы хотите, чтобы она выполнялась до самого завершения задачи, вам нужно будет использовать дескриптор соединения (join handle), чтобы дождаться завершения первой задачи. С потоками мы использовали метод join, чтобы «заблокироваться» до того, как поток закончит работу. В листинге 17-7 мы можем использовать await, чтобы сделать то же самое, потому что сам дескриптор задачи является фьючерсом. Его тип Output — это Result, поэтому мы также разворачиваем его (unwrap) после await.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let handle = trpl::spawn_task(async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        });

        for i in 1..5 {
            println!("hi number {i} from the second task!");
            trpl::sleep(Duration::from_millis(500)).await;
        }

        handle.await.unwrap();
    });
}
Листинг 17-7: Использование await с дескриптором соединения для выполнения задачи до завершения

Эта обновлённая версия выполняется до тех пор, пока оба цикла не завершатся:

hi number 1 from the second task!
hi number 1 from the first task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!
hi number 6 from the first task!
hi number 7 from the first task!
hi number 8 from the first task!
hi number 9 from the first task!

До сих пор похоже, что async и потоки дают нам схожие результаты, только с другим синтаксисом: использование await вместо вызова join на дескрипторе соединения и ожидание вызовов sleep.

Более существенное отличие в том, что нам не нужно было порождать другой поток операционной системы, чтобы сделать это. На самом деле нам даже не нужно порождать здесь задачу. Поскольку async-блоки компилируются в анонимные фьючерсы, мы можем поместить каждый цикл в async-блок и позволить среде выполнения выполнить оба до завершения с помощью функции trpl::join.

В разделе «Ожидание завершения всех потоков» в главе 16 мы показали, как использовать метод join на типе JoinHandle, возвращаемом при вызове std::thread::spawn. Функция trpl::join похожа, но для фьючерсов. Когда вы передаёте ей два фьючерса, она создаёт один новый фьючерс, вывод которого — кортеж, содержащий вывод каждого фьючерса, который вы передали, как только они оба завершатся. Таким образом, в листинге 17-8 мы используем trpl::join, чтобы дождаться завершения обоих fut1 и fut2. Мы не ожидаем fut1 и fut2, а вместо этого новый фьючерс, созданный trpl::join. Мы игнорируем вывод, потому что это просто кортеж, содержащий два единичных значения.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let fut1 = async {
            for i in 1..10 {
                println!("hi number {i} from the first task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let fut2 = async {
            for i in 1..5 {
                println!("hi number {i} from the second task!");
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        trpl::join(fut1, fut2).await;
    });
}
Листинг 17-8: Использование trpl::join для ожидания двух анонимных фьючерсов

Когда мы запускаем это, мы видим, что оба фьючерса выполняются до завершения:

hi number 1 from the first task!
hi number 1 from the second task!
hi number 2 from the first task!
hi number 2 from the second task!
hi number 3 from the first task!
hi number 3 from the second task!
hi number 4 from the first task!
hi number 4 from the second task!
hi number 5 from the first task!
hi number 6 from the first task!
hi number 7 from the first task!
hi number 8 from the first task!
hi number 9 from the first task!

Теперь вы будете видеть одинаковый порядок каждый раз, что сильно отличается от того, что мы видели с потоками и с trpl::spawn_task в листинге 17-7. Это потому, что функция trpl::join справедлива: она проверяет каждый фьючерс одинаково часто, чередуя их, и никогда не позволяет одному обогнать другого, если другой готов. С потоками операционная система решает, какой поток проверять и как долго ему работать. С async Rust среда выполнения решает, какую задачу проверять. (На практике детали усложняются, потому что async-среда выполнения может использовать потоки операционной системы под капотом как часть того, как она управляет конкурентностью, поэтому гарантировать справедливость может быть больше работы для среды выполнения — но это всё равно возможно!) Среды выполнения не обязаны гарантировать справедливость для любой данной операции, и они часто предлагают разные API, позволяющие вам выбирать, хотите вы справедливости или нет.

Попробуйте некоторые из этих вариаций ожидания фьючерсов и посмотрите, что они делают:

  • Удалите async-блок из одного или обоих циклов.
  • Ожидайте каждый async-блок сразу после его определения.
  • Оберните только первый цикл в async-блок и ожидайте получившийся фьючерс после тела второго цикла.

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

Отправка данных между двумя задачами с помощью передачи сообщений

Обмен данными между фьючерсами также будет знаком: мы снова будем использовать передачу сообщений, но на этот раз с async-версиями типов и функций. Мы пойдём несколько иным путём, чем в разделе «Передача данных между потоками с помощью передачи сообщений» в главе 16, чтобы проиллюстрировать некоторые ключевые различия между конкурентностью на основе потоков и конкурентностью на основе фьючерсов. В листинге 17-9 мы начнём только с одного async-блока — не порождая отдельную задачу, как мы порождали отдельный поток.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let val = String::from("hi");
        tx.send(val).unwrap();

        let received = rx.recv().await.unwrap();
        println!("received '{received}'");
    });
}
Листинг 17-9: Создание async-канала и назначение двух половин переменным tx и rx

Здесь мы используем trpl::channel — async-версию API канала с множеством производителей и одним потребителем, которую мы использовали с потоками в главе 16. Async-версия API лишь немного отличается от версии на основе потоков: она использует изменяемый, а не неизменяемый приёмник rx, и её метод recv производит фьючерс, который нам нужно ожидать, а не производит значение напрямую. Теперь мы можем отправлять сообщения от отправителя к приёмнику. Обратите внимание, что нам не нужно порождать отдельный поток или даже задачу; нам нужно только ожидать вызов rx.recv.

Синхронный метод Receiver::recv в std::mpsc::channel блокируется, пока не получит сообщение. Метод trpl::Receiver::recv этого не делает, потому что он async. Вместо блокировки он возвращает управление среде выполнения, пока не будет получено сообщение или пока не закроется отправляющая сторона канала. В отличие от этого, мы не ожидаем вызов send, потому что он не блокирует. Ему не нужно, потому что канал, в который мы его отправляем, неограничен (unbounded).

Примечание: Поскольку весь этот async-код выполняется в async-блоке в вызове trpl::block_on, всё внутри него может избегать блокировки. Однако код снаружи него будет блокироваться на возврате из функции block_on. В этом весь смысл функции trpl::block_on: она позволяет вам выбрать, где блокироваться на каком-то наборе async-кода, и, таким образом, где переходить между синхронным и async-кодом.

Обратите внимание на две вещи в этом примере. Во-первых, сообщение придёт сразу. Во-вторых, хотя мы здесь используем фьючерс, конкурентности пока нет. Всё в листинге происходит последовательно, так же как если бы фьючерсов не было.

Давайте решим первую часть, отправив серию сообщений и засыпая между ними, как показано в листинге 17-10.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("future"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            trpl::sleep(Duration::from_millis(500)).await;
        }

        while let Some(value) = rx.recv().await {
            println!("received '{value}'");
        }
    });
}
Листинг 17-10: Отправка и получение нескольких сообщений по async-каналу и сон с await между каждым сообщением

В дополнение к отправке сообщений нам нужно их получать. В этом случае, поскольку мы знаем, сколько сообщений придёт, мы могли бы сделать это вручную, вызвав rx.recv().await четыре раза. Однако в реальном мире мы обычно будем ждать неизвестного числа сообщений, поэтому нам нужно продолжать ждать, пока мы не определим, что больше сообщений нет.

В листинге 16-10 мы использовали цикл for для обработки всех элементов, полученных из синхронного канала. Однако у Rust пока нет способа использовать цикл for с асинхронно производимой серией элементов, поэтому нам нужно использовать цикл, который мы ещё не видели: условный цикл while let. Это версия цикла конструкции if let, которую мы видели в разделе «Краткий поток управления с if let и let...else» в главе 6. Цикл будет продолжать выполняться, пока указанный им шаблон продолжает соответствовать значению.

Вызов rx.recv производит фьючерс, который мы ожидаем. Среда выполнения приостановит фьючерс, пока он не будет готов. Как только сообщение прибывает, фьючерс разрешится в Some(message) столько раз, сколько прибывает сообщение. Когда канал закрывается, независимо от того, прибыли ли какие-либо сообщения, фьючерс вместо этого разрешится в None, чтобы указать, что больше значений нет и, следовательно, мы должны прекратить опрос — то есть прекратить ожидание.

Цикл while let объединяет всё это. Если результат вызова rx.recv().await — Some(message), мы получаем доступ к сообщению и можем использовать его в теле цикла, точно так же, как мы могли бы с if let. Если результат — None, цикл заканчивается. Каждый раз, когда цикл завершается, он снова достигает точки await, поэтому среда выполнения снова приостанавливает его, пока не придёт другое сообщение.

Теперь код успешно отправляет и получает все сообщения. К сожалению, всё ещё есть пара проблем. Во-первых, сообщения не прибывают с полусекундными интервалами. Они прибывают все сразу, через 2 секунды (2000 миллисекунд) после запуска программы. Во-вторых, эта программа также никогда не завершается! Вместо этого она ждёт новых сообщений вечно. Вам нужно будет остановить её с помощью ctrl-C.

Код внутри одного async-блока выполняется линейно

Давайте начнём с рассмотрения того, почему сообщения приходят все сразу после полной задержки, а не приходят с задержками между каждым. Внутри данного async-блока порядок, в котором появляются ключевые слова await в коде, также является порядком, в котором они выполняются при запуске программы.

В листинге 17-10 только один async-блок, поэтому всё в нём выполняется линейно. Конкурентности по-прежнему нет. Все вызовы tx.send происходят, перемежаясь со всеми вызовами trpl::sleep и связанными с ними точками await. Только затем цикл while let добирается до каких-либо точек await на вызовах recv.

Чтобы получить желаемое поведение, когда задержка сна происходит между каждым сообщением, нам нужно поместить операции tx и rx в их собственные async-блоки, как показано в листинге 17-11. Тогда среда выполнения может выполнять каждый из них отдельно с помощью trpl::join, как в листинге 17-8. Снова мы ожидаем результат вызова trpl::join, а не отдельные фьючерсы. Если бы мы ожидали отдельные фьючерсы последовательно, мы бы просто вернулись к последовательному потоку — именно то, чего мы пытаемся избежать.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx_fut = async {
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        trpl::join(tx_fut, rx_fut).await;
    });
}
Листинг 17-11: Разделение send и recv на их собственные async-блоки и ожидание фьючерсов для этих блоков

С обновлённым кодом в листинге 17-11 сообщения печатаются с интервалами 500 миллисекунд, а не все сразу через 2 секунды.

Перемещение владения в async-блок

Программа всё ещё никогда не завершается, хотя, из-за того, как цикл while let взаимодействует с trpl::join:

  • Фьючерс, возвращаемый trpl::join, завершается только после того, как оба переданных ему фьючерса завершатся.
  • Фьючерс tx_fut завершается после того, как он закончит спать после отправки последнего сообщения в vals.
  • Фьючерс rx_fut не завершится, пока не закончится цикл while let.
  • Цикл while let не закончится, пока ожидание rx.recv не произведёт None.
  • Ожидание rx.recv вернёт None только после того, как другой конец канала будет закрыт.
  • Канал закроется только в том случае, если мы вызовем rx.close или когда отправляющая сторона tx будет отброшена.
  • Мы нигде не вызываем rx.close, а tx не будет отброшен, пока не закончится самый внешний async-блок, переданный в trpl::block_on.
  • Блок не может закончиться, потому что он заблокирован на завершении trpl::join, что возвращает нас к началу этого списка.

Прямо сейчас async-блок, в котором мы отправляем сообщения, только заимствует tx, потому что отправка сообщения не требует владения, но если бы мы могли переместить tx в этот async-блок, он был бы отброшен, как только этот блок закончится. В разделе «Захват ссылок или перемещение владения» в главе 13 вы узнали, как использовать ключевое слово move с замыканиями, и, как обсуждалось в разделе «Использование замыканий move с потоками» в главе 16, нам часто нужно перемещать данные в замыкания при работе с потоками. Та же базовая динамика применима к async-блокам, поэтому ключевое слово move работает с async-блоками так же, как и с замыканиями.

В листинге 17-12 мы меняем блок, используемый для отправки сообщений, с async на async move.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx_fut = async move {
            // --snip--
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        trpl::join(tx_fut, rx_fut).await;
    });
}
Листинг 17-12: Пересмотр кода из листинга 17-11, который корректно завершается по завершении

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

Соединение нескольких фьючерсов с помощью макроса join!

Этот async-канал также является каналом с множеством производителей, поэтому мы можем вызвать clone на tx, если хотим отправлять сообщения из нескольких фьючерсов, как показано в листинге 17-13.

Имя файла: src/main.rs
extern crate trpl; // required for mdbook test

use std::time::Duration;

fn main() {
    trpl::block_on(async {
        let (tx, mut rx) = trpl::channel();

        let tx1 = tx.clone();
        let tx1_fut = async move {
            let vals = vec![
                String::from("hi"),
                String::from("from"),
                String::from("the"),
                String::from("future"),
            ];

            for val in vals {
                tx1.send(val).unwrap();
                trpl::sleep(Duration::from_millis(500)).await;
            }
        };

        let rx_fut = async {
            while let Some(value) = rx.recv().await {
                println!("received '{value}'");
            }
        };

        let tx_fut = async move {
            let vals = vec![
                String::from("more"),
                String::from("messages"),
                String::from("for"),
                String::from("you"),
            ];

            for val in vals {
                tx.send(val).unwrap();
                trpl::sleep(Duration::from_millis(1500)).await;
            }
        };

        trpl::join!(tx1_fut, tx_fut, rx_fut);
    });
}
Листинг 17-13: Использование нескольких производителей с async-блоками

Сначала мы клонируем tx, создавая tx1 вне первого async-блока. Мы перемещаем tx1 в этот блок точно так же, как делали раньше с tx. Затем позже мы перемещаем исходный tx в новый async-блок, где отправляем больше сообщений с немного более медленной задержкой. Мы случайно поместили этот новый async-блок после async-блока для получения сообщений, но он мог бы идти и перед ним. Ключ — это порядок, в котором фьючерсы ожидаются, а не в котором они создаются.

Оба async-блока для отправки сообщений должны быть блоками async move, чтобы и tx, и tx1 отбрасывались при завершении этих блоков. В противном случае мы вернёмся в тот же бесконечный цикл, с которого начали.

Наконец, мы переключаемся с trpl::join на trpl::join!, чтобы обработать дополнительный фьючерс: макрос join! ожидает произвольное число фьючерсов, когда число фьючерсов известно во время компиляции. Мы обсудим ожидание коллекции неизвестного числа фьючерсов позже в этой главе.

Теперь мы видим все сообщения от обоих фьючерсов-отправителей, и, поскольку фьючерсы-отправители используют немного разные задержки после отправки, сообщения также получаются с этими разными интервалами:

received 'hi'
received 'more'
received 'from'
received 'the'
received 'messages'
received 'future'
received 'for'
received 'you'

Мы рассмотрели, как использовать передачу сообщений для отправки данных между фьючерсами, как код внутри async-блока выполняется последовательно, как перемещать владение в async-блок и как соединять несколько фьючерсов. Далее давайте обсудим, как и зачем говорить среде выполнения, что она может переключиться на другую задачу.