Умные указатели и многопоточность

Изучи умные указатели `Box`, `Rc` и `RefCell`, а затем пиши параллельный код без гонок данных с потоками, каналами и `Arc<Mutex<T>>`.

  • Продвинутый
  • 22 мин
  • 10 вопросов
  • Урок 9 из 10

В этом уроке ты узнаешь

  • Хранить значение в куче через Box и строить рекурсивный тип
  • Создавать нескольких владельцев через Rc и внутреннюю изменяемость через RefCell
  • Запускать потоки с замыканиями move и собирать результаты через join
  • Обмениваться данными между потоками через каналы и Arc<Mutex<T>>

До сих пор у каждого значения был один владелец. Но иногда нужно другое: рекурсивная структура, размер которой заранее неизвестен, одна и та же песня в нескольких плейлистах, изменение общих данных или распределение работы между несколькими ядрами процессора. Для этого в Rust есть умные указатели и средства многопоточности (concurrency) — и они тоже подчиняются правилам владения.

`Box<T>`: значение в куче

Box::new(x) помещает значение в кучу, а в стеке остаётся только указатель фиксированного размера. Когда владелец коробки выходит из области видимости, значение в куче тоже автоматически удаляется. Box нужен в трёх случаях: рекурсивные типы, размер которых неизвестен при компиляции, трейт-объекты вроде Box<dyn Trait> и большие данные, которые дорого перемещать по стеку.

Ошибка E0072

enum List {
    Node(i32, List),
    Empty,
}

Правильно с `Box`

enum List {
    Node(i32, Box<List>),
    Empty,
}
Слева List содержит внутри себя List, поэтому компилятор пишет: recursive type List has infinite size. А Box — указатель фиксированного размера, он разрывает цикл.
Rust
enum List {
    Node(i32, Box<List>),
    Empty,
}

use List::{Empty, Node};

fn sum(list: &List) -> i32 {
    match list {
        Node(value, next) => value + sum(next),
        Empty => 0,
    }
}

fn main() {
    let boxed = Box::new(5);
    println!("boxed + 1 = {}", *boxed + 1);

    let list = Node(1, Box::new(Node(2, Box::new(Node(3, Box::new(Empty))))));
    println!("sum = {}", sum(&list));
}

Ожидаемый результат

boxed + 1 = 6
sum = 6

Чтобы читать дальше, зарегистрируйся бесплатно

Остальные разделы урока, тест и заметки открываются с аккаунтом Educora. Регистрация занимает минуту, а прогресс сохраняется на всех твоих устройствах.

`Rc<T>`: несколько владельцев

Rc (reference counting — подсчёт ссылок) позволяет одному значению иметь нескольких владельцев. Rc::clone(&x) не копирует данные, а лишь увеличивает счётчик на единицу — это очень дёшево. При удалении каждого владельца счётчик уменьшается, а когда он доходит до нуля, значение удаляется. Rc разрешает только чтение значения и работает только внутри одного потока.

Rust
use std::rc::Rc;

fn main() {
    let song = Rc::new(String::from("lesson.mp3"));
    println!("owners: {}", Rc::strong_count(&song));

    let playlist_a = Rc::clone(&song);
    {
        let playlist_b = Rc::clone(&song);
        println!("owners: {}", Rc::strong_count(&song));
        println!("b plays {playlist_b}");
    }
    println!("owners: {}", Rc::strong_count(&song));
    println!("a plays {playlist_a}");
}

Ожидаемый результат

owners: 1
owners: 3
b plays lesson.mp3
owners: 2
a plays lesson.mp3
playlist_b удалился в конце внутреннего блока, и счётчик упал с 3 до 2. Сам текст хранится в памяти только один раз.

`RefCell<T>`: внутренняя изменяемость

RefCell проверяет правила заимствования не при компиляции, а во время работы программы. borrow() выдаёт заимствование для чтения, borrow_mut() — для изменения. Это позволяет менять значение за неизменяемой ссылкой. Комбинация Rc<RefCell<T>> — типичное решение: несколько владельцев могут и читать, и изменять общие данные.

Rust
use std::cell::RefCell;
use std::rc::Rc;

fn main() {
    let scores = Rc::new(RefCell::new(vec![80, 95]));
    let teacher = Rc::clone(&scores);

    teacher.borrow_mut().push(70);
    scores.borrow_mut().push(100);

    println!("{:?}", scores.borrow());
    let total: i32 = teacher.borrow().iter().sum();
    println!("total = {total}");
}

Ожидаемый результат

[80, 95, 70, 100]
total = 345
ТипВладельцыИзменениеОбщий доступ из потоков
Box<T>одинесли владелец mutда
Rc<T>нескольконетнет
RefCell<T>одинда, с проверкой во время работынет — его можно передать в другой поток, но нельзя разделять (он не Sync)
Arc<T>нескольконетда
Arc<Mutex<T>>несколькода, через блокировкуда

Потоки

thread::spawn запускает замыкание в новом потоке и возвращает JoinHandle. join() ждёт завершения потока и отдаёт его результат. move перед замыканием передаёт потоку владение используемыми переменными. Внимание: строки, которые потоки печатают сами, при каждом запуске могут идти в разном порядке. Поэтому ниже потоки возвращают результаты, а main печатает их в фиксированном порядке.

Rust
use std::thread;

fn main() {
    let mut handles = Vec::new();
    for id in 1..=3_u64 {
        let handle = thread::spawn(move || {
            let sum: u64 = (1..=id * 1000).sum();
            (id, sum)
        });
        handles.push(handle);
    }
    for handle in handles {
        let (id, sum) = handle.join().unwrap();
        println!("thread {id}: sum = {sum}");
    }
}

Ожидаемый результат

thread 1: sum = 500500
thread 2: sum = 2001000
thread 3: sum = 4501500

Ошибка E0373

use std::thread;

fn main() {
    let names = vec!["Aysel", "Murad"];
    let handle = thread::spawn(|| {
        println!("{:?}", names);
    });
    handle.join().unwrap();
}

Правильно с `move`

use std::thread;

fn main() {
    let names = vec!["Aysel", "Murad"];
    let handle = thread::spawn(move || {
        println!("{:?}", names);
    });
    handle.join().unwrap();
}
Слева: closure may outlive the current function, but it borrows names. Поток может прожить дольше main, поэтому ссылки недостаточно. Программа справа выводит ["Aysel", "Murad"].

Каналы и `Arc<Mutex<T>>`

Обмениваться данными между потоками можно двумя способами. Первый — канал: mpsc::channel() создаёт передатчик (tx) и приёмник (rx), один поток отправляет через send, другой получает. Приёмник можно обходить циклом for — цикл закончится, когда все передатчики будут удалены. Сообщения от одного отправителя приходят в порядке отправки.

Rust
use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let worker = thread::spawn(move || {
        for step in ["download", "unpack", "install"] {
            tx.send(step).unwrap();
        }
    });
    for message in rx {
        println!("got: {message}");
    }
    worker.join().unwrap();
    println!("done");
}

Ожидаемый результат

got: download
got: unpack
got: install
done

Второй способ — общее состояние. Arc — потокобезопасный (атомарный) вариант Rc, а Mutex — блокировка: поток, вызвавший lock(), получает единоличный доступ к данным, а когда возвращённый охранник (guard) выходит из области видимости, блокировка снимается автоматически. Вместе Arc<Mutex<T>> позволяет нескольким потокам по очереди изменять одно значение.

Rust
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = Vec::new();
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        handles.push(thread::spawn(move || {
            let mut n = counter.lock().unwrap();
            *n += 1;
        }));
    }
    for handle in handles {
        handle.join().unwrap();
    }
    println!("Result: {}", *counter.lock().unwrap());
}

Ожидаемый результат

Result: 10
В каком бы порядке ни работали потоки, благодаря блокировке результат всегда равен 10. Каждый поток получает свою копию Arc — это записано через затенение: let counter = Arc::clone(&counter);.

Запомни

  • Box<T> хранит значение в куче; он нужен для рекурсивных типов и dyn Trait.
  • Rc<T> даёт нескольких владельцев в одном потоке; Rc::clone лишь увеличивает счётчик.
  • RefCell<T> проверяет правила заимствования во время работы; нарушение вызывает панику.
  • thread::spawn(move || ...) запускает поток, join() ждёт результат; печатай в фиксированном порядке из main.
  • Каналы передают сообщения, а Arc<Mutex<T>> даёт общее изменяемое состояние между потоками.
Заметил ошибку или неточность в уроке?

Проверь себя

Вопросов: 10. Каждый правильный ответ приносит XP.

Вопрос 1 / 10

Вопрос 1 / 10. Почему не компилируется enum List { Node(i32, List), Empty }?