До сих пор у каждого значения был один владелец. Но иногда нужно другое: рекурсивная структура, размер которой заранее неизвестен, одна и та же песня в нескольких плейлистах, изменение общих данных или распределение работы между несколькими ядрами процессора. Для этого в 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 — указатель фиксированного размера, он разрывает цикл.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 разрешает только чтение значения и работает только внутри одного потока.
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>> — типичное решение: несколько владельцев могут и читать, и изменять общие данные.
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 печатает их в фиксированном порядке.
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 — цикл закончится, когда все передатчики будут удалены. Сообщения от одного отправителя приходят в порядке отправки.
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>> позволяет нескольким потокам по очереди изменять одно значение.
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
Arc — это записано через затенение: let counter = Arc::clone(&counter);.Запомни
Box<T>хранит значение в куче; он нужен для рекурсивных типов иdyn Trait.Rc<T>даёт нескольких владельцев в одном потоке;Rc::cloneлишь увеличивает счётчик.RefCell<T>проверяет правила заимствования во время работы; нарушение вызывает панику.thread::spawn(move || ...)запускает поток,join()ждёт результат; печатай в фиксированном порядке изmain.- Каналы передают сообщения, а
Arc<Mutex<T>>даёт общее изменяемое состояние между потоками.