Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Использование потоков для одновременного выполнения кода

В большинстве современных операционных систем код выполняемой программы выполняется в процессе, и операционная система управляет несколькими процессами одновременно. Внутри программы вы также можете иметь независимые части, которые выполняются одновременно. Функции, которые выполняют эти независимые части, называются потоками. Например, веб-сервер может иметь несколько потоков, чтобы он мог отвечать на более чем один запрос одновременно.

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

  • Состояния гонки, в которых потоки обращаются к данным или ресурсам в несогласованном порядке
  • Взаимные блокировки, в которых два потока ждут друг друга, не позволяя обоим потокам продолжить
  • Ошибки, которые возникают только в определённых ситуациях и которые трудно воспроизвести и исправить надёжно

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

Языки программирования реализуют потоки несколькими разными способами, и многие операционные системы предоставляют API, который язык программирования может вызывать для создания новых потоков. Стандартная библиотека Rust использует модель 1:1 реализации потоков, при которой программа использует один поток операционной системы на один поток языка. Есть крейты, которые реализуют другие модели потоков, которые делают другие компромиссы по сравнению с моделью 1:1. (Асинхронная система Rust, которую мы увидим в следующей главе, также предоставляет другой подход к конкурентности.)

Создание нового потока с помощью spawn

Чтобы создать новый поток, мы вызываем функцию thread::spawn и передаём ей замыкание (мы говорили о замыканиях в главе 13), содержащее код, который мы хотим выполнить в новом потоке. Пример в листинге 16-1 печатает некоторый текст из основного потока и другой текст из нового потока.

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

fn main() {
    thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {i} from the spawned thread!");
            thread::sleep(Duration::from_millis(1));
        }
    });

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

Обратите внимание, что когда основной поток программы на Rust завершается, все порождённые потоки завершаются, независимо от того, закончили ли они выполнение. Вывод этой программы может немного отличаться каждый раз, но он будет выглядеть примерно так:

hi number 1 from the main thread!
hi number 1 from the spawned thread!
hi number 2 from the main thread!
hi number 2 from the spawned thread!
hi number 3 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the main thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!

Вызовы thread::sleep заставляют поток остановить своё выполнение на короткое время, позволяя другому потоку выполняться. Потоки, вероятно, будут чередоваться, но это не гарантируется: это зависит от того, как ваша операционная система планирует потоки. В этом запуске основной поток напечатал первым, хотя оператор печати из порождённого потока появляется первым в коде. И хотя мы сказали порождённому потоку печатать, пока i не станет 9, он успел только до 5, прежде чем основной поток завершился.

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

Ожидание завершения всех потоков

Код в листинге 16-1 не только останавливает порождённый поток преждевременно в большинстве случаев из-за завершения основного потока, но и, поскольку нет гарантии порядка выполнения потоков, мы также не можем гарантировать, что порождённый поток получит возможность выполняться вообще!

Мы можем решить проблему того, что порождённый поток не выполняется или завершается преждевременно, сохранив возвращаемое значение thread::spawn в переменной. Тип возвращаемого значения thread::spawn — JoinHandle<T>. JoinHandle<T> — это принадлежащее значение, которое, когда мы вызываем на нём метод join, будет ждать, пока его поток не завершится. Листинг 16-2 показывает, как использовать JoinHandle<T> потока, который мы создали в листинге 16-1, и как вызвать join, чтобы убедиться, что порождённый поток завершится до выхода main.

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

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {i} from the spawned thread!");
            thread::sleep(Duration::from_millis(1));
        }
    });

    for i in 1..5 {
        println!("hi number {i} from the main thread!");
        thread::sleep(Duration::from_millis(1));
    }

    handle.join().unwrap();
}
Листинг 16-2: Сохранение JoinHandle<T> из thread::spawn для гарантии того, что поток выполнится до конца

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

hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 1 from the spawned thread!
hi number 3 from the main thread!
hi number 2 from the spawned thread!
hi number 4 from the main thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!

Два потока продолжают чередоваться, но основной поток ждёт из-за вызова handle.join() и не заканчивается, пока порождённый поток не завершится.

Но давайте посмотрим, что произойдёт, если мы вместо этого переместим handle.join() перед циклом for в main, вот так:

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

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("hi number {i} from the spawned thread!");
            thread::sleep(Duration::from_millis(1));
        }
    });

    handle.join().unwrap();

    for i in 1..5 {
        println!("hi number {i} from the main thread!");
        thread::sleep(Duration::from_millis(1));
    }
}

Основной поток будет ждать завершения порождённого потока, а затем запустит свой цикл for, поэтому вывод больше не будет чередоваться, как показано здесь:

hi number 1 from the spawned thread!
hi number 2 from the spawned thread!
hi number 3 from the spawned thread!
hi number 4 from the spawned thread!
hi number 5 from the spawned thread!
hi number 6 from the spawned thread!
hi number 7 from the spawned thread!
hi number 8 from the spawned thread!
hi number 9 from the spawned thread!
hi number 1 from the main thread!
hi number 2 from the main thread!
hi number 3 from the main thread!
hi number 4 from the main thread!

Мелкие детали, такие как место вызова join, могут повлиять на то, будут ли ваши потоки выполняться одновременно.

Использование замыканий move с потоками

Мы часто будем использовать ключевое слово move с замыканиями, передаваемыми в thread::spawn, потому что тогда замыкание забирает владение значениями, которые оно использует из окружения, тем самым передавая владение этими значениями из одного потока в другой. В «Захват ссылок или перемещение владения» в главе 13 мы обсуждали move в контексте замыканий. Теперь мы сосредоточимся больше на взаимодействии между move и thread::spawn.

Обратите внимание в листинге 16-1, что замыкание, которое мы передаём в thread::spawn, не принимает аргументов: мы не используем никаких данных из основного потока в коде порождённого потока. Чтобы использовать данные из основного потока в порождённом потоке, замыкание порождённого потока должно захватить нужные ему значения. Листинг 16-3 показывает попытку создать вектор в основном потоке и использовать его в порождённом потоке. Однако это пока не сработает, как вы увидите через мгновение.

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

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {v:?}");
    });

    handle.join().unwrap();
}
Листинг 16-3: Попытка использовать вектор, созданный основным потоком, в другом потоке

Замыкание использует v, поэтому оно захватит v и сделает его частью окружения замыкания. Поскольку thread::spawn выполняет это замыкание в новом потоке, мы должны иметь возможность доступа к v внутри этого нового потока. Но когда мы компилируем этот пример, мы получаем следующую ошибку:

$ cargo run
   Compiling threads v0.1.0 (file:///projects/threads)
error[E0373]: closure may outlive the current function, but it borrows `v`, which is owned by the current function
 --> src/main.rs:6:32
  |
6 |     let handle = thread::spawn(|| {
  |                                ^^ may outlive borrowed value `v`
7 |         println!("Here's a vector: {v:?}");
  |                                     - `v` is borrowed here
  |
note: function requires argument type to outlive `'static`
 --> src/main.rs:6:18
  |
6 |       let handle = thread::spawn(|| {
  |  __________________^
7 | |         println!("Here's a vector: {v:?}");
8 | |     });
  | |______^
help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
  |
6 |     let handle = thread::spawn(move || {
  |                                ++++

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

Rust выводит, как захватывать v, и поскольку println! нужна только ссылка на v, замыкание пытается заимствовать v. Однако есть проблема: Rust не может определить, как долго будет выполняться порождённый поток, поэтому он не знает, будет ли ссылка на v всегда допустимой.

Листинг 16-4 предоставляет сценарий, в котором более вероятно наличие ссылки на v, которая не будет допустимой.

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

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(|| {
        println!("Here's a vector: {v:?}");
    });

    drop(v); // ой-ой!

    handle.join().unwrap();
}
Листинг 16-4: Поток с замыканием, которое пытается захватить ссылку на v из основного потока, который удаляет v

Если бы Rust позволил нам выполнить этот код, была бы вероятность, что порождённый поток был бы немедленно помещён в фоновый режим, вообще не выполнившись. У порождённого потока есть ссылка на v внутри, но основной поток немедленно удаляет v, используя функцию drop, которую мы обсуждали в главе 15. Затем, когда порождённый поток начнёт выполняться, v больше недействителен, поэтому ссылка на него также недействительна. О нет!

Чтобы исправить ошибку компилятора в листинге 16-3, мы можем воспользоваться советом из сообщения об ошибке:

help: to force the closure to take ownership of `v` (and any other referenced variables), use the `move` keyword
  |
6 |     let handle = thread::spawn(move || {
  |                                ++++

Добавив ключевое слово move перед замыканием, мы заставляем замыкание взять владение значениями, которые оно использует, вместо того чтобы позволить Rust вывести, что оно должно заимствовать значения. Модификация листинга 16-3, показанная в листинге 16-5, скомпилируется и выполнится, как мы задумали.

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

fn main() {
    let v = vec![1, 2, 3];

    let handle = thread::spawn(move || {
        println!("Here's a vector: {v:?}");
    });

    handle.join().unwrap();
}
Листинг 16-5: Использование ключевого слова move, чтобы заставить замыкание взять владение значениями, которые оно использует

Мы могли бы быть искушены попробовать то же самое, чтобы исправить код в листинге 16-4, где основной поток вызывал drop, используя замыкание move. Однако это исправление не сработает, потому что то, что пытается сделать листинг 16-4, запрещено по другой причине. Если бы мы добавили move к замыканию, мы бы переместили v в окружение замыкания, и мы больше не могли бы вызывать drop на нём в основном потоке. Вместо этого мы получили бы эту ошибку компилятора:

$ cargo run
   Compiling threads v0.1.0 (file:///projects/threads)
error[E0382]: use of moved value: `v`
  --> src/main.rs:10:10
   |
 4 |     let v = vec![1, 2, 3];
   |         - move occurs because `v` has type `Vec<i32>`, which does not implement the `Copy` trait
 5 |
 6 |     let handle = thread::spawn(move || {
   |                                ------- value moved into closure here
 7 |         println!("Here's a vector: {v:?}");
   |                                     - variable moved due to use in closure
...
10 |     drop(v); // oh no!
   |          ^ value used here after move
   |
help: consider cloning the value before moving it into the closure
   |
 6 ~     let value = v.clone();
 7 ~     let handle = thread::spawn(move || {
 8 ~         println!("Here's a vector: {value:?}");
   |

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

Правила владения Rust снова спасли нас! Мы получили ошибку из кода в листинге 16-3, потому что Rust был консервативен и только заимствовал v для потока, что означало, что основной поток теоретически мог сделать недействительной ссылку порождённого потока. Сказав Rust переместить владение v в порождённый поток, мы гарантируем Rust, что основной поток больше не будет использовать v. Если мы изменим листинг 16-4 таким же образом, мы нарушим правила владения, когда попытаемся использовать v в основном потоке. Ключевое слово move переопределяет консервативное поведение Rust по умолчанию — заимствование; оно не позволяет нам нарушать правила владения.

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