RefCell<T> и паттерн внутренней изменяемости
Внутренняя изменяемость — это паттерн проектирования в Rust, который позволяет изменять
данные даже при наличии неизменяемых ссылок на эти данные; обычно это
действие запрещено правилами заимствования. Для изменения данных паттерн использует
unsafe-код внутри структуры данных, чтобы обойти обычные правила Rust, управляющие
изменением и заимствованием. Небезопасный код указывает компилятору, что мы
проверяем правила вручную, а не полагаемся на компилятор в их проверке
за нас; подробнее о небезопасном коде мы поговорим в главе 20.
Мы можем использовать типы, применяющие паттерн внутренней изменяемости, только когда можем
гарантировать, что правила заимствования будут соблюдаться во время выполнения, даже если
компилятор не может этого гарантировать. Задействованный unsafe-код затем оборачивается в
безопасный API, а внешний тип по-прежнему остаётся неизменяемым.
Давайте исследуем эту концепцию, рассмотрев тип RefCell<T>, который следует
паттерну внутренней изменяемости.
Проверка правил заимствования во время выполнения
В отличие от Rc<T>, тип RefCell<T> представляет единоличное владение данными,
которые он хранит. Так что же отличает RefCell<T> от такого типа, как Box<T>?
Вспомните правила заимствования, которые вы узнали в главе 4:
- В любой момент времени у вас может быть либо одна изменяемая ссылка, либо любое количество неизменяемых ссылок (но не обе одновременно).
- Ссылки всегда должны быть действительными.
Для ссылок и Box<T> инварианты правил заимствования проверяются
во время компиляции. Для RefCell<T> эти инварианты проверяются во время выполнения.
При использовании ссылок, если вы нарушите эти правила, вы получите ошибку компилятора. При использовании
RefCell<T>, если вы нарушите эти правила, ваша программа запаникует и завершится.
Преимущества проверки правил заимствования во время компиляции заключаются в том, что ошибки будут обнаружены раньше в процессе разработки, и нет никакого влияния на производительность во время выполнения, поскольку весь анализ выполняется заранее. По этим причинам проверка правил заимствования во время компиляции — лучший выбор в большинстве случаев, поэтому это поведение по умолчанию в Rust.
Преимущество проверки правил заимствования во время выполнения, напротив, заключается в том, что определённые безопасные с точки зрения памяти сценарии становятся разрешёнными, тогда как они были бы запрещены проверками во время компиляции. Статический анализ, как в компиляторе Rust, по своей сути консервативен. Некоторые свойства кода невозможно обнаружить путём анализа кода: самый известный пример — проблема останова, которая выходит за рамки этой книги, но является интересной темой для исследования.
Поскольку некоторый анализ невозможен, если компилятор Rust не может быть уверен, что
код соблюдает правила владения, он может отклонить корректную программу; таким
образом он консервативен. Если бы Rust принимал некорректную программу, пользователи
не могли бы доверять гарантиям, которые даёт Rust. Однако если Rust отклоняет
корректную программу, программист будет испытывать неудобства, но ничего
катастрофического не произойдёт. Тип RefCell<T> полезен, когда вы уверены, что ваш
код соблюдает правила заимствования, но компилятор не может это понять и
гарантировать.
Подобно Rc<T>, RefCell<T> предназначен только для использования в однопоточных сценариях
и выдаст ошибку во время компиляции, если вы попытаетесь использовать его в многопоточном
контексте. Мы поговорим о том, как получить функциональность RefCell<T> в
многопоточной программе, в главе 16.
Вот краткое изложение причин выбрать Box<T>, Rc<T> или RefCell<T>:
Rc<T>позволяет нескольким владельцам одних и тех же данных;Box<T>иRefCell<T>имеют одного владельца.Box<T>допускает неизменяемые или изменяемые заимствования, проверяемые во время компиляции;Rc<T>допускает только неизменяемые заимствования, проверяемые во время компиляции;RefCell<T>допускает неизменяемые или изменяемые заимствования, проверяемые во время выполнения.- Поскольку
RefCell<T>допускает изменяемые заимствования, проверяемые во время выполнения, вы можете изменять значение внутриRefCell<T>, даже когдаRefCell<T>является неизменяемым.
Изменение значения внутри неизменяемого значения — это паттерн внутренней изменяемости. Давайте рассмотрим ситуацию, в которой внутренняя изменяемость полезна, и изучим, как она возможна.
Использование внутренней изменяемости
Следствием правил заимствования является то, что когда у вас есть неизменяемое значение, вы не можете заимствовать его изменяемо. Например, этот код не скомпилируется:
fn main() {
let x = 5;
let y = &mut x;
}
Если вы попытаетесь скомпилировать этот код, вы получите следующую ошибку:
$ cargo run
Compiling borrowing v0.1.0 (file:///projects/borrowing)
error[E0596]: cannot borrow `x` as mutable, as it is not declared as mutable
--> src/main.rs:3:13
|
3 | let y = &mut x;
| ^^^^^^ cannot borrow as mutable
|
help: consider changing this to be mutable
|
2 | let mut x = 5;
| +++
For more information about this error, try `rustc --explain E0596`.
error: could not compile `borrowing` (bin "borrowing") due to 1 previous error
Однако существуют ситуации, когда было бы полезно, чтобы значение изменяло
себя в своих методах, но выглядело неизменяемым для другого кода. Код вне
методов значения не смог бы изменять значение. Использование RefCell<T> —
один из способов получить возможность внутренней изменяемости, но RefCell<T>
не обходит правила заимствования полностью: проверка заимствований в
компиляторе допускает эту внутреннюю изменяемость, а правила заимствования проверяются
во время выполнения. Если вы нарушите правила, вы получите panic! вместо
ошибки компилятора.
Давайте рассмотрим практический пример, где мы можем использовать RefCell<T> для изменения
неизменяемого значения, и увидим, почему это полезно.
Тестирование с mock-объектами
Иногда во время тестирования программист использует один тип вместо другого, чтобы наблюдать определённое поведение и убедиться, что оно реализовано правильно. Этот тип-заглушка называется test double. Подумайте о нём в смысле дублёра в кинематографе, где человек вступает в роль и заменяет актёра в особо сложной сцене. Test double заменяют другие типы, когда мы запускаем тесты. Mock-объекты — это особые виды test double, которые записывают, что происходит во время теста, чтобы вы могли убедиться, что были выполнены правильные действия.
В Rust нет объектов в том же смысле, в каком объекты есть в других языках, и в Rust нет функциональности mock-объектов, встроенной в стандартную библиотеку, как в некоторых других языках. Однако вы вполне можете создать структуру, которая будет служить тем же целям, что и mock-объект.
Вот сценарий, который мы будем тестировать: мы создадим библиотеку, которая отслеживает значение относительно максимального значения и отправляет сообщения в зависимости от того, насколько близко к максимальному значению находится текущее значение. Эта библиотека может использоваться для отслеживания квоты пользователя на количество разрешённых ему вызовов API, например.
Наша библиотека будет предоставлять только функциональность отслеживания того, насколько близко к
максимуму находится значение и какими должны быть сообщения в какие моменты. Приложения,
использующие нашу библиотеку, должны будут предоставить механизм отправки
сообщений: приложение может показывать сообщение пользователю напрямую, отправлять
электронное письмо, отправлять текстовое сообщение или делать что-то ещё. Библиотеке не нужно
знать эти детали. Всё, что ей нужно, — это что-то, реализующее предоставляемый нами трейт
под названием Messenger. В листинге 15-20 показан код библиотеки.
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
Одна важная часть этого кода — трейт Messenger имеет один метод
под названием send, который принимает неизменяемую ссылку на self и текст
сообщения. Этот трейт — интерфейс, который должен реализовать наш mock-объект, чтобы
mock можно было использовать так же, как настоящий объект. Другая важная часть
заключается в том, что мы хотим протестировать поведение метода set_value у
LimitTracker. Мы можем изменить то, что передаём в параметр value, но
set_value ничего не возвращает, чтобы мы могли делать утверждения. Мы хотим иметь возможность
сказать, что если мы создаём LimitTracker с чем-то, реализующим
трейт Messenger, и определённым значением для max, messenger получает указание
отправить соответствующие сообщения, когда мы передаём разные числа для value.
Нам нужен mock-объект, который вместо отправки электронного письма или текстового сообщения при
вызове send будет только записывать сообщения, которые ему велено отправить. Мы можем
создать новый экземпляр mock-объекта, создать LimitTracker, использующий
mock-объект, вызвать метод set_value у LimitTracker, а затем проверить, что
mock-объект содержит ожидаемые нами сообщения. В листинге 15-21 показана попытка
реализовать mock-объект именно для этого, но проверка заимствований не позволит это сделать.
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
struct MockMessenger {
sent_messages: Vec<String>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: vec![],
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.len(), 1);
}
}
MockMessenger, которая не разрешена проверкой заимствованийЭтот тестовый код определяет структуру MockMessenger с полем sent_messages
типа Vec значений String для отслеживания сообщений, которые ей велено
отправить. Мы также определяем ассоциированную функцию new, чтобы было удобно
создавать новые значения MockMessenger, начиная с пустого списка сообщений. Затем
мы реализуем трейт Messenger для MockMessenger, чтобы можно было передать
MockMessenger в LimitTracker. В определении метода send мы
берём сообщение, переданное в качестве параметра, и сохраняем его в списке
sent_messages объекта MockMessenger.
В тесте мы проверяем, что происходит, когда LimitTracker получает указание установить
value в значение, превышающее 75 процентов от max. Сначала мы
создаём новый MockMessenger, который начнёт с пустого списка сообщений.
Затем создаём новый LimitTracker и передаём ему ссылку на новый
MockMessenger и значение max, равное 100. Мы вызываем метод set_value у
LimitTracker со значением 80, что больше 75 процентов от 100.
Затем мы утверждаем, что список сообщений, который отслеживает MockMessenger,
теперь должен содержать одно сообщение.
Однако с этим тестом есть одна проблема, как показано здесь:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
error[E0596]: cannot borrow `self.sent_messages` as mutable, as it is behind a `&` reference
--> src/lib.rs:58:13
|
58 | self.sent_messages.push(String::from(message));
| ^^^^^^^^^^^^^^^^^^ `self` is a `&` reference, so it cannot be borrowed as mutable
|
help: consider changing this to be a mutable reference in the `impl` method and the `trait` definition
|
2 ~ fn send(&mut self, msg: &str);
3 | }
...
56 | impl Messenger for MockMessenger {
57 ~ fn send(&mut self, message: &str) {
|
For more information about this error, try `rustc --explain E0596`.
error: could not compile `limit-tracker` (lib test) due to 1 previous error
Мы не можем изменить MockMessenger, чтобы он отслеживал сообщения, потому что
метод send принимает неизменяемую ссылку на self. Мы также не можем принять
предложение из текста ошибки использовать &mut self как в методе impl, так и
в определении трейта. Мы не хотим менять трейт Messenger исключительно ради
тестирования. Вместо этого нам нужно найти способ заставить наш тестовый код работать
правильно с нашей существующей архитектурой.
Это ситуация, в которой может помочь внутренняя изменяемость! Мы будем хранить
sent_messages внутри RefCell<T>, и тогда метод send сможет
изменять sent_messages, чтобы сохранять сообщения, которые мы видели. Листинг 15-22 показывает,
как это выглядит.
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
self.sent_messages.borrow_mut().push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
// --snip--
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
RefCell<T> для изменения внутреннего значения, в то время как внешнее значение считается неизменяемымПоле sent_messages теперь имеет тип RefCell<Vec<String>> вместо
Vec<String>. В функции new мы создаём новый экземпляр RefCell<Vec<String>>
вокруг пустого вектора.
Для реализации метода send первый параметр по-прежнему является
неизменяемым заимствованием self, что соответствует определению трейта. Мы вызываем
borrow_mut для RefCell<Vec<String>> в self.sent_messages, чтобы получить
изменяемую ссылку на значение внутри RefCell<Vec<String>>, то есть на
вектор. Затем мы можем вызвать push для изменяемой ссылки на вектор, чтобы
отслеживать сообщения, отправленные во время теста.
Последнее изменение, которое нам нужно сделать, — в утверждении: чтобы увидеть, сколько элементов
во внутреннем векторе, мы вызываем borrow для RefCell<Vec<String>>, чтобы получить
неизменяемую ссылку на вектор.
Теперь, когда вы увидели, как использовать RefCell<T>, давайте углубимся в то, как это работает!
Отслеживание заимствований во время выполнения
При создании неизменяемых и изменяемых ссылок мы используем синтаксис & и &mut
соответственно. С RefCell<T> мы используем методы borrow и borrow_mut,
которые являются частью безопасного API, принадлежащего RefCell<T>. Метод
borrow возвращает тип умного указателя Ref<T>, а borrow_mut —
тип умного указателя RefMut<T>. Оба типа реализуют Deref, поэтому мы
можем обращаться с ними как с обычными ссылками.
RefCell<T> отслеживает, сколько умных указателей Ref<T> и RefMut<T>
активно в данный момент. Каждый раз, когда мы вызываем borrow, RefCell<T>
увеличивает свой счётчик активных неизменяемых заимствований. Когда значение Ref<T>
выходит из области видимости, счётчик неизменяемых заимствований уменьшается на 1. Так же
как и правила заимствования во время компиляции, RefCell<T> позволяет нам иметь много неизменяемых
заимствований или одно изменяемое заимствование в любой момент времени.
Если мы попытаемся нарушить эти правила, вместо ошибки компилятора, как было бы
со ссылками, реализация RefCell<T> запаникует во
время выполнения. В листинге 15-23 показана модификация реализации send из
листинга 15-22. Мы намеренно пытаемся создать два активных изменяемых заимствования
в одной области видимости, чтобы показать, что RefCell<T> не позволяет нам делать это
во время выполнения.
pub trait Messenger {
fn send(&self, msg: &str);
}
pub struct LimitTracker<'a, T: Messenger> {
messenger: &'a T,
value: usize,
max: usize,
}
impl<'a, T> LimitTracker<'a, T>
where
T: Messenger,
{
pub fn new(messenger: &'a T, max: usize) -> LimitTracker<'a, T> {
LimitTracker {
messenger,
value: 0,
max,
}
}
pub fn set_value(&mut self, value: usize) {
self.value = value;
let percentage_of_max = self.value as f64 / self.max as f64;
if percentage_of_max >= 1.0 {
self.messenger.send("Error: You are over your quota!");
} else if percentage_of_max >= 0.9 {
self.messenger
.send("Urgent warning: You've used up over 90% of your quota!");
} else if percentage_of_max >= 0.75 {
self.messenger
.send("Warning: You've used up over 75% of your quota!");
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use std::cell::RefCell;
struct MockMessenger {
sent_messages: RefCell<Vec<String>>,
}
impl MockMessenger {
fn new() -> MockMessenger {
MockMessenger {
sent_messages: RefCell::new(vec![]),
}
}
}
impl Messenger for MockMessenger {
fn send(&self, message: &str) {
let mut one_borrow = self.sent_messages.borrow_mut();
let mut two_borrow = self.sent_messages.borrow_mut();
one_borrow.push(String::from(message));
two_borrow.push(String::from(message));
}
}
#[test]
fn it_sends_an_over_75_percent_warning_message() {
let mock_messenger = MockMessenger::new();
let mut limit_tracker = LimitTracker::new(&mock_messenger, 100);
limit_tracker.set_value(80);
assert_eq!(mock_messenger.sent_messages.borrow().len(), 1);
}
}
RefCell<T> запаникуетМы создаём переменную one_borrow для умного указателя RefMut<T>, возвращаемого
из borrow_mut. Затем мы создаём ещё одно изменяемое заимствование таким же образом в
переменной two_borrow. Это создаёт две изменяемые ссылки в одной области видимости,
что не разрешено. Когда мы запускаем тесты для нашей библиотеки, код из листинга
15-23 скомпилируется без ошибок, но тест завершится неудачно:
$ cargo test
Compiling limit-tracker v0.1.0 (file:///projects/limit-tracker)
Finished `test` profile [unoptimized + debuginfo] target(s) in 0.91s
Running unittests src/lib.rs (target/debug/deps/limit_tracker-e599811fa246dbde)
running 1 test
test tests::it_sends_an_over_75_percent_warning_message ... FAILED
failures:
---- tests::it_sends_an_over_75_percent_warning_message stdout ----
thread 'tests::it_sends_an_over_75_percent_warning_message' (6028024) panicked at src/lib.rs:60:53:
RefCell already borrowed
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
failures:
tests::it_sends_an_over_75_percent_warning_message
test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
error: test failed, to rerun pass `--lib`
Обратите внимание, что код запаниковал с сообщением already borrowed: BorrowMutError. Именно так RefCell<T> обрабатывает нарушения
правил заимствования во время выполнения.
Выбор отлавливать ошибки заимствования во время выполнения, а не во время компиляции,
как мы сделали здесь, означает, что вы потенциально будете обнаруживать ошибки в своём коде позже
в процессе разработки: возможно, только после того, как ваш код будет развёрнут в
производственной среде. Кроме того, ваш код будет нести небольшой штраф по производительности
во время выполнения из-за отслеживания заимствований во время выполнения, а не во время компиляции.
Однако использование RefCell<T> позволяет написать mock-объект, который может
изменять себя, чтобы отслеживать увиденные сообщения, пока вы используете его
в контексте, где разрешены только неизменяемые значения. Вы можете использовать RefCell<T>,
несмотря на его компромиссы, чтобы получить больше функциональности, чем предоставляют
обычные ссылки.
Разрешение нескольких владельцев изменяемых данных
Распространённый способ использования RefCell<T> — в сочетании с Rc<T>. Вспомните, что
Rc<T> позволяет иметь несколько владельцев некоторых данных, но предоставляет только неизменяемый
доступ к этим данным. Если у вас есть Rc<T>, содержащий RefCell<T>, вы можете
получить значение, которое может иметь несколько владельцев и которое вы можете изменять!
Например, вспомните пример cons-списка в листинге 15-18, где мы использовали
Rc<T>, чтобы несколько списков могли совместно владеть другим списком. Поскольку
Rc<T> хранит только неизменяемые значения, мы не можем изменить какие-либо значения в
списке после того, как мы их создали. Давайте добавим RefCell<T> ради его способности
изменять значения в списках. В листинге 15-24 показано, что, используя
RefCell<T> в определении Cons, мы можем изменить значение, хранящееся во всех
списках.
#[derive(Debug)]
enum List {
Cons(Rc<RefCell<i32>>, Rc<List>),
Nil,
}
use crate::List::{Cons, Nil};
use std::cell::RefCell;
use std::rc::Rc;
fn main() {
let value = Rc::new(RefCell::new(5));
let a = Rc::new(Cons(Rc::clone(&value), Rc::new(Nil)));
let b = Cons(Rc::new(RefCell::new(3)), Rc::clone(&a));
let c = Cons(Rc::new(RefCell::new(4)), Rc::clone(&a));
*value.borrow_mut() += 10;
println!("a after = {a:?}");
println!("b after = {b:?}");
println!("c after = {c:?}");
}
Rc<RefCell<i32>> для создания List, который мы можем изменятьМы создаём значение, являющееся экземпляром Rc<RefCell<i32>>, и сохраняем его в
переменной с именем value, чтобы позже иметь к нему прямой доступ. Затем мы создаём
List в a с вариантом Cons, содержащим value. Нам нужно клонировать
value, чтобы и a, и value владели внутренним значением 5,
вместо передачи владения от value к a или заимствования a
у value.
Мы оборачиваем список a в Rc<T>, чтобы, когда мы создаём списки b и c,
они оба могли ссылаться на a, как мы делали в листинге 15-18.
После того как мы создали списки в a, b и c, мы хотим добавить 10 к
значению в value. Мы делаем это, вызывая borrow_mut для value, что использует
возможность автоматического разыменования, которую мы обсуждали в разделе «Где оператор ->?» в главе 5, чтобы разыменовать
Rc<T> до внутреннего значения RefCell<T>. Метод borrow_mut возвращает
умный указатель RefMut<T>, и мы используем для него оператор разыменования и изменяем
внутреннее значение.
Когда мы выводим a, b и c, мы видим, что все они имеют изменённое
значение 15 вместо 5:
$ cargo run
Compiling cons-list v0.1.0 (file:///projects/cons-list)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.63s
Running `target/debug/cons-list`
a after = Cons(RefCell { value: 15 }, Nil)
b after = Cons(RefCell { value: 3 }, Cons(RefCell { value: 15 }, Nil))
c after = Cons(RefCell { value: 4 }, Cons(RefCell { value: 15 }, Nil))
Этот приём довольно изящен! Используя RefCell<T>, мы имеем внешне
неизменяемое значение List. Но мы можем использовать методы RefCell<T>, которые
обеспечивают доступ к его внутренней изменяемости, чтобы мы могли изменять наши данные, когда
это необходимо. Проверки правил заимствования во время выполнения защищают нас от гонок данных, и
иногда стоит пожертвовать немного скоростью ради этой гибкости в наших структурах
данных. Обратите внимание, что RefCell<T> не работает для многопоточного кода!
Mutex<T> — это потокобезопасная версия RefCell<T>, и мы обсудим
Mutex<T> в главе 16.