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

Rc<T>, умный указатель с подсчётом ссылок

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

Множественное владение нужно включать явно, используя тип Rust Rc<T>, что является сокращением от подсчёта ссылок. Тип Rc<T> отслеживает количество ссылок на значение, чтобы определить, используется ли значение всё ещё. Если ссылок на значение ноль, значение может быть очищено без того, чтобы какие-либо ссылки стали недействительными.

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

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

Обратите внимание, что Rc<T> предназначен только для использования в однопоточных сценариях. Когда мы будем обсуждать конкурентность в главе 16, мы рассмотрим, как выполнять подсчёт ссылок в многопоточных программах.

Совместное использование данных

Давайте вернёмся к нашему примеру cons-списка из листинга 15-5. Напомним, что мы определили его с помощью Box<T>. На этот раз мы создадим два списка, которые оба владеют третьим списком. Концептуально это похоже на рисунок 15-3.

Связный список с меткой 'a', указывающий на три элемента. Первый элемент содержит целое число 5 и указывает на второй элемент. Второй элемент содержит целое число 10 и указывает на третий элемент. Третий элемент содержит значение 'Nil', означающее конец списка; он никуда не указывает. Связный список с меткой 'b' указывает на элемент, содержащий целое число 3, и указывает на первый элемент списка 'a'. Связный список с меткой 'c' указывает на элемент, содержащий целое число 4, и также указывает на первый элемент списка 'a', так что хвосты списков 'b' и 'c' оба являются списком 'a'.

Рисунок 15-3: Два списка, b и c, совместно владеющие третьим списком, a

Мы создадим список a, который содержит 5, а затем 10. Затем мы создадим два других списка: b, который начинается с 3, и c, который начинается с 4. Оба списка b и c затем продолжат к первому списку a, содержащему 5 и 10. Другими словами, оба списка будут совместно владеть первым списком, содержащим 5 и 10.

Попытка реализовать этот сценарий с использованием нашего определения List с Box<T> не сработает, как показано в листинге 15-17.

Имя файла: src/main.rs
enum List {
    Cons(i32, Box<List>),
    Nil,
}

use crate::List::{Cons, Nil};

fn main() {
    let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
    let b = Cons(3, Box::new(a));
    let c = Cons(4, Box::new(a));
}
Листинг 15-17: Демонстрация того, что нам не разрешено иметь два списка, использующих Box<T>, которые пытаются совместно владеть третьим списком

Когда мы компилируем этот код, мы получаем эту ошибку:

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
error[E0382]: use of moved value: `a`
  --> src/main.rs:11:30
   |
 9 |     let a = Cons(5, Box::new(Cons(10, Box::new(Nil))));
   |         - move occurs because `a` has type `List`, which does not implement the `Copy` trait
10 |     let b = Cons(3, Box::new(a));
   |                              - value moved here
11 |     let c = Cons(4, Box::new(a));
   |                              ^ value used here after move
   |
note: if `List` implemented `Clone`, you could clone the value
  --> src/main.rs:1:1
   |
 1 | enum List {
   | ^^^^^^^^^ consider implementing `Clone` for this type
...
10 |     let b = Cons(3, Box::new(a));
   |                              - you could clone this value

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

Варианты Cons владеют данными, которые они содержат, поэтому, когда мы создаём список b, a перемещается в b и b владеет a. Затем, когда мы пытаемся снова использовать a при создании c, нам это не разрешено, потому что a был перемещён.

Мы могли бы изменить определение Cons, чтобы хранить ссылки вместо этого, но тогда нам пришлось бы указать параметры времени жизни. Указывая параметры времени жизни, мы бы указывали, что каждый элемент в списке будет жить по крайней мере столько же, сколько весь список. Это верно для элементов и списков в листинге 15-17, но не в каждом сценарии.

Вместо этого мы изменим наше определение List, чтобы использовать Rc<T> вместо Box<T>, как показано в листинге 15-18. Каждый вариант Cons теперь будет хранить значение и Rc<T>, указывающий на List. Когда мы создаём b, вместо того чтобы принимать владение a, мы клонируем Rc<List>, которым владеет a, тем самым увеличивая количество ссылок с одного до двух и позволяя a и b совместно владеть данными в этом Rc<List>. Мы также клонируем a при создании c, увеличивая количество ссылок с двух до трёх. Каждый раз, когда мы вызываем Rc::clone, счётчик ссылок на данные внутри Rc<List> будет увеличиваться, и данные не будут очищены, пока на них не будет ноль ссылок.

Имя файла: src/main.rs
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    let b = Cons(3, Rc::clone(&a));
    let c = Cons(4, Rc::clone(&a));
}
Листинг 15-18: Определение List, использующее Rc<T>

Нам нужно добавить инструкцию use, чтобы ввести Rc<T> в область видимости, потому что его нет в прелюдии. В main мы создаём список, содержащий 5 и 10, и сохраняем его в новом Rc<List> в a. Затем, когда мы создаём b и c, мы вызываем функцию Rc::clone и передаём ссылку на Rc<List> в a в качестве аргумента.

Мы могли бы вызвать a.clone() вместо Rc::clone(&a), но соглашение Rust — использовать Rc::clone в этом случае. Реализация Rc::clone не делает глубокую копию всех данных, как это делают реализации clone большинства типов. Вызов Rc::clone только увеличивает счётчик ссылок, что не занимает много времени. Глубокие копии данных могут занимать много времени. Используя Rc::clone для подсчёта ссылок, мы можем визуально отличить разновидности клонирования с глубокой копией от разновидностей клонирования, которые увеличивают счётчик ссылок. При поиске проблем с производительностью в коде нам нужно учитывать только клоны с глубокой копией и можно не обращать внимания на вызовы Rc::clone.

Клонирование для увеличения счётчика ссылок

Давайте изменим наш рабочий пример в листинге 15-18 так, чтобы мы могли видеть, как счётчик ссылок меняется при создании и удалении ссылок на Rc<List> в a.

В листинге 15-19 мы изменим main так, чтобы у него была внутренняя область видимости вокруг списка c; затем мы сможем увидеть, как изменяется счётчик ссылок, когда c выходит из области видимости.

Имя файла: src/main.rs
enum List {
    Cons(i32, Rc<List>),
    Nil,
}

use crate::List::{Cons, Nil};
use std::rc::Rc;

// --snip--

fn main() {
    let a = Rc::new(Cons(5, Rc::new(Cons(10, Rc::new(Nil)))));
    println!("count after creating a = {}", Rc::strong_count(&a));
    let b = Cons(3, Rc::clone(&a));
    println!("count after creating b = {}", Rc::strong_count(&a));
    {
        let c = Cons(4, Rc::clone(&a));
        println!("count after creating c = {}", Rc::strong_count(&a));
    }
    println!("count after c goes out of scope = {}", Rc::strong_count(&a));
}
Листинг 15-19: Печать счётчика ссылок

В каждой точке программы, где изменяется счётчик ссылок, мы печатаем счётчик ссылок, который получаем, вызывая функцию Rc::strong_count. Эта функция называется strong_count, а не count, потому что у типа Rc<T> есть также weak_count; мы увидим, для чего используется weak_count, в разделе «Предотвращение циклов ссылок с помощью Weak<T>».

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

$ cargo run
   Compiling cons-list v0.1.0 (file:///projects/cons-list)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.45s
     Running `target/debug/cons-list`
count after creating a = 1
count after creating b = 2
count after creating c = 3
count after c goes out of scope = 2

Мы видим, что Rc<List> в a имеет начальный счётчик ссылок 1; затем каждый раз, когда мы вызываем clone, счётчик увеличивается на 1. Когда c выходит из области видимости, счётчик уменьшается на 1. Нам не нужно вызывать функцию для уменьшения счётчика ссылок, как мы должны вызывать Rc::clone для увеличения счётчика ссылок: реализация трейта Drop автоматически уменьшает счётчик ссылок, когда значение Rc<T> выходит из области видимости.

Чего мы не можем увидеть в этом примере, так это то, что когда b, а затем a выходят из области видимости в конце main, счётчик становится равным 0, и Rc<List> полностью очищается. Использование Rc<T> позволяет одному значению иметь нескольких владельцев, а счётчик гарантирует, что значение остаётся действительным, пока существует любой из владельцев.

Через неизменяемые ссылки Rc<T> позволяет совместно использовать данные между несколькими частями программы только для чтения. Если бы Rc<T> позволял также иметь несколько изменяемых ссылок, можно было бы нарушить одно из правил заимствования, обсуждавшихся в главе 4: несколько изменяемых заимствований одного и того же места могут вызвать гонки данных и несоответствия. Но возможность изменять данные очень полезна! В следующем разделе мы обсудим паттерн внутренней изменяемости и тип RefCell<T>, который можно использовать вместе с Rc<T>, чтобы обойти это ограничение неизменяемости.