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

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

Один из всё более популярных подходов к обеспечению безопасной конкурентности — передача сообщений, при которой потоки или акторы взаимодействуют, отправляя друг другу сообщения, содержащие данные. Вот идея в виде лозунга из документации языка Go: «Не общайтесь через разделяемую память; вместо этого разделяйте память через общение».

Чтобы реализовать конкурентность через отправку сообщений, стандартная библиотека Rust предоставляет реализацию каналов. Канал — это общая концепция программирования, при которой данные отправляются из одного потока в другой.

Вы можете представить канал в программировании как направленный канал воды, например ручей или реку. Если вы поместите что-то вроде резиновой уточки в реку, она поплывёт вниз по течению до конца водного пути.

У канала есть две половины: передатчик и приёмник. Половина-передатчик — это место вверх по течению, куда вы кладёте резиновую уточку в реку, а половина-приёмник — это место, куда уточка попадает вниз по течению. Одна часть вашего кода вызывает методы на передатчике с данными, которые вы хотите отправить, а другая часть проверяет принимающий конец на наличие прибывающих сообщений. Говорят, что канал закрыт, если отброшена любая из половин — передатчик или приёмник.

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

Сначала в листинге 16-6 мы создадим канал, но не будем с ним ничего делать. Обратите внимание, что это ещё не скомпилируется, потому что Rust не может определить, какой тип значений мы хотим отправлять по каналу.

Имя файла: src/main.rs
use std::sync::mpsc;

fn main() {
    let (tx, rx) = mpsc::channel();
}
Листинг 16-6: Создание канала и назначение двух половин переменным tx и rx

Мы создаём новый канал с помощью функции mpsc::channel; mpsc расшифровывается как multiple producer, single consumer (множество производителей, один потребитель). Короче говоря, способ, которым стандартная библиотека Rust реализует каналы, означает, что канал может иметь несколько отправляющих концов, которые производят значения, но только один принимающий конец, который потребляет эти значения. Представьте несколько ручьёв, впадающих вместе в одну большую реку: всё, что отправлено вниз по любому из ручьёв, в конце окажется в одной реке. Пока мы начнём с одного производителя, но добавим несколько производителей, когда заработает этот пример.

Функция mpsc::channel возвращает кортеж, первый элемент которого — отправляющий конец (передатчик), а второй элемент — принимающий конец (приёмник). Сокращения tx и rx традиционно используются во многих областях для transmitter (передатчик) и receiver (приёмник) соответственно, поэтому мы так называем наши переменные, чтобы обозначить каждый конец. Мы используем оператор let с шаблоном, который деструктурирует кортеж; мы обсудим использование шаблонов в операторах let и деструктуризацию в главе 19. Пока просто знайте, что использование оператора let таким образом — удобный подход к извлечению частей кортежа, возвращаемого mpsc::channel.

Давайте переместим передающий конец в порождённый поток и заставим его отправить одну строку, чтобы порождённый поток взаимодействовал с главным потоком, как показано в листинге 16-7. Это похоже на помещение резиновой уточки в реку вверх по течению или на отправку сообщения в чате из одного потока в другой.

Имя файла: src/main.rs
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });
}
Листинг 16-7: Перемещение tx в порождённый поток и отправка "hi"

Снова мы используем thread::spawn, чтобы создать новый поток, а затем используем move, чтобы переместить tx в замыкание, чтобы порождённый поток владел tx. Порождённому потоку нужно владеть передатчиком, чтобы иметь возможность отправлять сообщения через канал.

У передатчика есть метод send, который принимает значение, которое мы хотим отправить. Метод send возвращает тип Result<T, E>, поэтому, если приёмник уже был отброшен и отправлять значение некуда, операция отправки вернёт ошибку. В этом примере мы вызываем unwrap, чтобы вызвать панику в случае ошибки. Но в реальном приложении мы бы обработали её должным образом: обратитесь к главе 9, чтобы повторить стратегии правильной обработки ошибок.

В листинге 16-8 мы получим значение от приёмника в главном потоке. Это похоже на извлечение резиновой уточки из воды в конце реки или на получение сообщения в чате.

Имя файла: src/main.rs
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
    });

    let received = rx.recv().unwrap();
    println!("Got: {received}");
}
Листинг 16-8: Получение значения "hi" в главном потоке и его печать

У приёмника есть два полезных метода: recv и try_recv. Мы используем recv, сокращение от receive (получать), который заблокирует выполнение главного потока и будет ждать, пока значение не будет отправлено по каналу. Как только значение отправлено, recv вернёт его в Result<T, E>. Когда передатчик закрывается, recv вернёт ошибку, сигнализирующую, что больше значений не будет.

Метод try_recv не блокирует, а вместо этого немедленно возвращает Result<T, E>: значение Ok, содержащее сообщение, если оно доступно, и значение Err, если в этот раз сообщений нет. Использование try_recv полезно, если у этого потока есть другая работа, которую можно делать в ожидании сообщений: мы могли бы написать цикл, который вызывает try_recv время от времени, обрабатывает сообщение, если оно доступно, и в противном случае выполняет другую работу в течение некоторого времени, пока снова не проверит.

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

Когда мы запустим код из листинга 16-8, мы увидим значение, напечатанное из главного потока:

Got: hi

Отлично!

Передача владения через каналы

Правила владения играют жизненно важную роль в отправке сообщений, потому что они помогают писать безопасный конкурентный код. Предотвращение ошибок в конкурентном программировании — это преимущество размышления о владении на протяжении всех ваших программ на Rust. Давайте проведём эксперимент, чтобы показать, как каналы и владение работают вместе, чтобы предотвратить проблемы: мы попытаемся использовать значение val в порождённом потоке после того, как мы отправили его по каналу. Попробуйте скомпилировать код из листинга 16-9, чтобы увидеть, почему этот код не разрешён.

Имя файла: src/main.rs
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let val = String::from("hi");
        tx.send(val).unwrap();
        println!("val is {val}");
    });

    let received = rx.recv().unwrap();
    println!("Got: {received}");
}
Листинг 16-9: Попытка использовать val после того, как мы отправили её по каналу

Здесь мы пытаемся напечатать val после того, как отправили её по каналу через tx.send. Разрешить это было бы плохой идеей: как только значение было отправлено в другой поток, этот поток может изменить или отбросить его до того, как мы попытаемся использовать значение снова. Потенциально модификации другого потока могли бы вызвать ошибки или неожиданные результаты из-за противоречивых или несуществующих данных. Однако Rust выдаёт нам ошибку, если мы попытаемся скомпилировать код из листинга 16-9:

$ cargo run
   Compiling message-passing v0.1.0 (file:///projects/message-passing)
error[E0382]: borrow of moved value: `val`
  --> src/main.rs:10:27
   |
 8 |         let val = String::from("hi");
   |             --- move occurs because `val` has type `String`, which does not implement the `Copy` trait
 9 |         tx.send(val).unwrap();
   |                 --- value moved here
10 |         println!("val is {val}");
   |                           ^^^ value borrowed here after move

For more information about this error, try `rustc --explain E0382`.
error: could not compile `message-passing` (bin "message-passing") due to 1 previous error

Наша конкурентная ошибка вызвала ошибку времени компиляции. Функция send принимает владение своим параметром, и когда значение перемещается, приёмник принимает владение им. Это не позволяет нам случайно использовать значение снова после его отправки; система владения проверяет, что всё в порядке.

Отправка нескольких значений

Код из листинга 16-8 скомпилировался и запустился, но он не показал нам ясно, что два отдельных потока общаются друг с другом через канал.

В листинге 16-10 мы внесли некоторые изменения, которые докажут, что код из листинга 16-8 выполняется конкурентно: порождённый поток теперь будет отправлять несколько сообщений и делать паузу на секунду между каждым сообщением.

Имя файла: src/main.rs
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for received in rx {
        println!("Got: {received}");
    }
}
Листинг 16-10: Отправка нескольких сообщений и пауза между каждым

На этот раз у порождённого потока есть вектор строк, которые мы хотим отправить главному потоку. Мы перебираем их, отправляя каждую отдельно, и делаем паузу между каждым вызовом функции thread::sleep со значением Duration в одну секунду.

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

При запуске кода из листинга 16-10 вы должны увидеть следующий вывод с одной секундной паузой между каждой строкой:

Got: hi
Got: from
Got: the
Got: thread

Поскольку у нас нет никакого кода, который делает паузу или задержку в цикле for главного потока, мы можем сказать, что главный поток ждёт получения значений от порождённого потока.

Создание нескольких производителей

Ранее мы упоминали, что mpsc — это аббревиатура от multiple producer, single consumer (множество производителей, один потребитель). Давайте используем mpsc и расширим код из листинга 16-10, чтобы создать несколько потоков, которые все отправляют значения одному и тому же приёмнику. Мы можем сделать это, клонировав передатчик, как показано в листинге 16-11.

Имя файла: src/main.rs
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    // --snip--

    let (tx, rx) = mpsc::channel();

    let tx1 = tx.clone();
    thread::spawn(move || {
        let vals = vec![
            String::from("hi"),
            String::from("from"),
            String::from("the"),
            String::from("thread"),
        ];

        for val in vals {
            tx1.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

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

        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for received in rx {
        println!("Got: {received}");
    }

    // --snip--
}
Листинг 16-11: Отправка нескольких сообщений от нескольких производителей

На этот раз, прежде чем мы создадим первый порождённый поток, мы вызываем clone на передатчике. Это даст нам новый передатчик, который мы можем передать первому порождённому потоку. Мы передаём исходный передатчик второму порождённому потоку. Это даёт нам два потока, каждый из которых отправляет разные сообщения одному приёмнику.

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

Got: hi
Got: more
Got: from
Got: messages
Got: for
Got: the
Got: thread
Got: you

В зависимости от вашей системы вы можете увидеть значения в другом порядке. Это то, что делает конкурентность интересной и одновременно сложной. Если вы поэкспериментируете с thread::sleep, задавая ему различные значения в разных потоках, каждый запуск будет более недетерминированным и создаст разный вывод каждый раз.

Теперь, когда мы рассмотрели, как работают каналы, давайте посмотрим на другой метод конкурентности.