Горячие клавиши

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

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

Нажмите ? для показа этой справки

Нажмите Esc для скрытия этой справки

Конкурентность с разделяемым состоянием

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

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

В некотором смысле каналы в любом языке программирования похожи на единоличное владение, потому что, как только вы передаёте значение по каналу, вы больше не должны использовать это значение. Конкурентность с разделяемой памятью подобна множественному владению: несколько потоков могут одновременно обращаться к одному и тому же месту в памяти. Как вы видели в главе 15, где умные указатели сделали возможным множественное владение, множественное владение может добавить сложности, потому что эти разные владельцы нуждаются в управлении. Система типов и правила владения Rust сильно помогают в правильном управлении. Для примера давайте рассмотрим мьютексы — один из наиболее распространённых примитивов конкурентности для разделяемой памяти.

Управление доступом с помощью мьютексов

Mutex — это сокращение от mutual exclusion (взаимное исключение): мьютекс позволяет только одному потоку обращаться к некоторым данным в любой момент времени. Чтобы получить доступ к данным в мьютексе, поток должен сначала сообщить, что он хочет получить доступ, запросив захват блокировки мьютекса. Блокировка — это структура данных, которая является частью мьютекса и отслеживает, кто в настоящее время имеет исключительный доступ к данным. Поэтому говорят, что мьютекс охраняет данные, которые он содержит, с помощью системы блокировок.

Мьютексы имеют репутацию сложных в использовании, потому что нужно помнить два правила:

  1. Необходимо попытаться захватить блокировку перед использованием данных.
  2. Когда вы закончили с данными, которые охраняет мьютекс, необходимо разблокировать данные, чтобы другие потоки могли захватить блокировку.

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

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

API Mutex<T>

В качестве примера использования мьютекса давайте начнём с использования мьютекса в однопоточном контексте, как показано в листинге 16-12.

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

fn main() {
    let m = Mutex::new(5);

    {
        let mut num = m.lock().unwrap();
        *num = 6;
    }

    println!("m = {m:?}");
}
Листинг 16-12: Исследование API Mutex<T> в однопоточном контексте для простоты

Как и со многими типами, мы создаём Mutex<T> с помощью ассоциированной функции new. Чтобы получить доступ к данным внутри мьютекса, мы используем метод lock для захвата блокировки. Этот вызов заблокирует текущий поток, чтобы он не мог выполнять никакой работы, пока не наступит наша очередь получить блокировку.

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

После того, как мы захватили блокировку, мы можем рассматривать возвращаемое значение, названное num в этом случае, как изменяемую ссылку на данные внутри. Система типов гарантирует, что мы захватим блокировку перед использованием значения в m. Тип m — Mutex<i32>, а не i32, поэтому мы должны вызвать lock, чтобы иметь возможность использовать значение i32. Мы не можем забыть; система типов не позволит нам получить доступ к внутреннему i32 иначе.

Вызов lock возвращает тип под названием MutexGuard, обёрнутый в LockResult, который мы обработали вызовом unwrap. Тип MutexGuard реализует Deref, чтобы указывать на наши внутренние данные; тип также имеет реализацию Drop, которая автоматически освобождает блокировку, когда MutexGuard выходит из области видимости, что происходит в конце внутренней области видимости. В результате мы не рискуем забыть освободить блокировку и заблокировать мьютекс от использования другими потоками, потому что освобождение блокировки происходит автоматически.

После снятия блокировки мы можем напечатать значение мьютекса и увидеть, что нам удалось изменить внутренний i32 на 6.

Разделяемый доступ к Mutex<T>

Теперь давайте попробуем разделить значение между несколькими потоками с помощью Mutex<T>. Мы запустим 10 потоков и заставим каждый из них увеличить значение счётчика на 1, так что счётчик пойдёт от 0 до 10. Пример в листинге 16-13 вызовет ошибку компилятора, и мы используем эту ошибку, чтобы узнать больше об использовании Mutex<T> и о том, как Rust помогает нам правильно его использовать.

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

fn main() {
    let counter = Mutex::new(0);
    let mut handles = vec![];

    for _ in 0..10 {
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}
Листинг 16-13: Десять потоков, каждый увеличивает счётчик, охраняемый Mutex<T>

Мы создаём переменную counter для хранения i32 внутри Mutex<T>, как мы делали в листинге 16-12. Затем мы создаём 10 потоков, итерируя по диапазону чисел. Мы используем thread::spawn и даём всем потокам одно и то же замыкание: то, которое перемещает счётчик в поток, захватывает блокировку Mutex<T> вызовом метода lock, а затем добавляет 1 к значению в мьютексе. Когда поток завершает выполнение своего замыкания, num выйдет из области видимости и освободит блокировку, чтобы другой поток мог её захватить.

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

Мы намекнули, что этот пример не скомпилируется. Теперь давайте выясним почему!

$ cargo run
   Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0382]: borrow of moved value: `counter`
  --> src/main.rs:21:29
   |
 5 |     let counter = Mutex::new(0);
   |         ------- move occurs because `counter` has type `std::sync::Mutex<i32>`, which does not implement the `Copy` trait
...
 8 |     for _ in 0..10 {
   |     -------------- inside of this loop
 9 |         let handle = thread::spawn(move || {
   |                                    ------- value moved into closure here, in previous iteration of loop
...
21 |     println!("Result: {}", *counter.lock().unwrap());
   |                             ^^^^^^^ value borrowed here after move

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

Сообщение об ошибке указывает, что значение counter было перемещено в предыдущей итерации цикла. Rust сообщает нам, что мы не можем переместить владение блокировкой counter в несколько потоков. Давайте исправим ошибку компилятора с помощью метода множественного владения, который мы обсуждали в главе 15.

Множественное владение с несколькими потоками

В главе 15 мы дали значение нескольким владельцам, используя умный указатель Rc<T> для создания значения со счётчиком ссылок. Давайте сделаем то же самое здесь и посмотрим, что произойдёт. Мы обернём Mutex<T> в Rc<T> в листинге 16-14 и клонируем Rc<T> перед перемещением владения в поток.

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

fn main() {
    let counter = Rc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Rc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}
Листинг 16-14: Попытка использовать Rc<T>, чтобы несколько потоков владели Mutex<T>

Снова компилируем и получаем… другие ошибки! Компилятор учит нас многому:

$ cargo run
   Compiling shared-state v0.1.0 (file:///projects/shared-state)
error[E0277]: `Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely
  --> src/main.rs:11:36
   |
11 |           let handle = thread::spawn(move || {
   |                        ------------- ^------
   |                        |             |
   |  ______________________|_____________within this `{closure@src/main.rs:11:36: 11:43}`
   | |                      |
   | |                      required by a bound introduced by this call
12 | |             let mut num = counter.lock().unwrap();
13 | |
14 | |             *num += 1;
15 | |         });
   | |_________^ `Rc<std::sync::Mutex<i32>>` cannot be sent between threads safely
   |
   = help: within `{closure@src/main.rs:11:36: 11:43}`, the trait `Send` is not implemented for `Rc<std::sync::Mutex<i32>>`
note: required because it's used within this closure
  --> src/main.rs:11:36
   |
11 |         let handle = thread::spawn(move || {
   |                                    ^^^^^^^
note: required by a bound in `spawn`
  --> /rustc/2d8144b7880597b6e6d3dfd63a9a9efae3f533d3/library/std/src/thread/functions.rs:125:0

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

Ух, это сообщение об ошибке очень многословное! Вот важная часть, на которой нужно сосредоточиться: `Rc<Mutex<i32>>` cannot be sent between threads safely. Компилятор также сообщает нам причину: the trait `Send` is not implemented for `Rc<Mutex<i32>>`. Мы поговорим о Send в следующем разделе: это один из трейтов, который гарантирует, что типы, которые мы используем с потоками, предназначены для использования в конкурентных ситуациях.

К сожалению, Rc<T> небезопасно разделять между потоками. Когда Rc<T> управляет счётчиком ссылок, он добавляет к счётчику при каждом вызове clone и вычитает из счётчика при каждом удалении клона. Но он не использует никаких примитивов конкурентности, чтобы гарантировать, что изменения счётчика не могут быть прерваны другим потоком. Это может привести к неправильным значениям счётчика — тонким ошибкам, которые, в свою очередь, могут привести к утечкам памяти или к тому, что значение будет удалено до того, как мы закончим с ним. Нам нужен тип, который точно такой же, как Rc<T>, но который изменяет счётчик ссылок потокобезопасным способом.

Атомарный подсчёт ссылок с помощью Arc<T>

К счастью, Arc<T> — это тип, подобный Rc<T>, который безопасно использовать в конкурентных ситуациях. a означает atomic (атомарный), что означает, что это атомарно подсчитываемый ссылками тип. Атомики — это дополнительный вид примитива конкурентности, который мы не будем здесь подробно рассматривать: см. документацию стандартной библиотеки для std::sync::atomic для получения дополнительной информации. На данном этапе вам просто нужно знать, что атомики работают как примитивные типы, но безопасны для разделения между потоками.

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

Давайте вернёмся к нашему примеру: Arc<T> и Rc<T> имеют одинаковый API, поэтому мы исправляем нашу программу, изменив строку use, вызов new и вызов clone. Код в листинге 16-15 наконец скомпилируется и запустится.

Имя файла: src/main.rs
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();

            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Result: {}", *counter.lock().unwrap());
}
Листинг 16-15: Использование Arc<T> для обёртывания Mutex<T>, чтобы иметь возможность разделять владение между несколькими потоками

Этот код напечатает следующее:

Result: 10

Мы сделали это! Мы посчитали от 0 до 10, что может показаться не очень впечатляющим, но это научило нас многому о Mutex<T> и потокобезопасности. Вы также можете использовать структуру этой программы для выполнения более сложных операций, чем просто инкремент счётчика. Используя эту стратегию, вы можете разделить вычисление на независимые части, распределить эти части по потокам, а затем использовать Mutex<T>, чтобы каждый поток обновлял окончательный результат своей частью.

Обратите внимание, что если вы выполняете простые числовые операции, есть типы проще, чем типы Mutex<T>, предоставляемые модулем std::sync::atomic стандартной библиотеки. Эти типы обеспечивают безопасный, конкурентный, атомарный доступ к примитивным типам. Мы выбрали использование Mutex<T> с примитивным типом для этого примера, чтобы мы могли сосредоточиться на том, как работает Mutex<T>.

Сравнение RefCell<T>/Rc<T> и Mutex<T>/Arc<T>

Вы могли заметить, что counter неизменяем, но мы могли получить изменяемую ссылку на значение внутри него; это означает, что Mutex<T> обеспечивает внутреннюю изменяемость, как и семейство Cell. Точно так же, как мы использовали RefCell<T> в главе 15, чтобы позволить нам изменять содержимое внутри Rc<T>, мы используем Mutex<T> для изменения содержимого внутри Arc<T>.

Ещё одна деталь, которую следует отметить, — Rust не может защитить вас от всех видов логических ошибок при использовании Mutex<T>. Вспомните из главы 15, что использование Rc<T> сопряжено с риском создания циклов ссылок, где два значения Rc<T> ссылаются друг на друга, вызывая утечки памяти. Аналогично, Mutex<T> сопряжён с риском создания взаимных блокировок (deadlock). Они возникают, когда операция должна заблокировать два ресурса, и два потока уже захватили по одной из блокировок, заставляя их ждать друг друга вечно. Если вас интересуют взаимные блокировки, попробуйте создать программу на Rust, которая имеет взаимную блокировку; затем исследуйте стратегии смягчения взаимных блокировок для мьютексов в любом языке и попробуйте реализовать их на Rust. Документация API стандартной библиотеки для Mutex<T> и MutexGuard предлагает полезную информацию.

Мы завершим эту главу разговором о трейтах Send и Sync и о том, как мы можем использовать их с пользовательскими типами.