Need holistic explanation about Rust’s cell and reference counted types

by

There are two essential concepts in Rust:

  • Ownership,
  • Mutability.

The various pointer types (Box, Rc, Arc) are concerned with Ownership: they allow controlling whether there is a single or multiple owners for a single object.

On the other hand, the various cells (Cell, RefCell, Mutex, RwLock, AtomicXXX) are concerned with Mutability.

The founding rule of Rust’s safety is Aliasing XOR Mutability. That is, an object can only be safely mutated if there is no outstanding reference to its interior.

This rule is generally enforced at compile time by the borrow checker:

  • if you have a &T, you cannot also have a &mut T to the same object in scope,
  • if you have a &mut T, you cannot also have any reference to the same object in scope.

However, sometimes, this is not flexible enough. Sometimes you DO need (or want) the ability to have multiple references to the same object and yet mutate it. Enter the cells.

The idea of Cell and RefCell is to permit mutability in the presence of aliasing in a controlled manner:

  • Cell prevents the formation of reference to its interior, avoiding dangling references,
  • RefCell shifts the enforcement of Aliasing XOR Mutability from compile time to runtime.

This functionality is sometimes described as providing interior mutability, that is where an object which otherwise looks immutable from the outside (&T) can actually be mutated.

When this mutability extends across multiple threads, you will instead use Mutex, RwLock or AtomicXXX; they provide the same functionality:

  • AtomicXXX are just Cell: no reference to the interior, just moving in/out,
  • RwLock is just RefCell: can obtain references to the interior through guards,
  • Mutex is a simplified version of RwLock which does not distinguish between a read-only guard and write guard; so conceptually similar to a RefCell with only a borrow_mut method.

If you come from a C++ background:

  • Box is unique_ptr,
  • Arc is shared_ptr,
  • Rc is a non thread-safe version of shared_ptr.

And the cells provide a similar functionality as mutable, except with additional guarantees to avoid aliasing issues; think of Cell as std::atomic and RefCell as a non thread-safe version of std::shared_mutex (which throws instead of blocking if the lock is taken).

Related Contents:

  1. Why doesn’t println! work in Rust unit tests?
  2. Why are Rust executables so huge?
  3. How do I split a string in Rust?
  4. What is the difference between Copy and Clone?
  5. What are non-lexical lifetimes?
  6. How to print a Vec?
  7. What do I have to do to solve a “use of moved value” error?
  8. Is there a modulus (not remainder) function / operation?
  9. Using map with Vectors
  10. How I can mutate a struct’s field from a method?
  11. Get the String length in characters in Rust
  12. References to traits in structs
  13. How do I check if a thing is in a vector
  14. Why are recursive struct types illegal in Rust?
  15. How to switch between Rust toolchains?
  16. How do I get an owned value out of a `Box`?
  17. Are there queue and stack collections in Rust?
  18. Lifetimes in Rust
  19. Why is it discouraged to accept a reference &String, &Vec, or &Box as a function argument?
  20. How do I create a map from a list in a functional way?
  21. How can I get cargo to recompile changed files automatically?
  22. How to implement a custom ‘fmt::Debug’ trait?
  23. The compiler suggests I add a ‘static lifetime because the parameter type may not live long enough, but I don’t think that’s what I want
  24. How can I randomly select one element from a vector or array?
  25. Is it considered a bad practice to implement Deref for newtypes?
  26. How can I download Rust API docs?
  27. Returning a closure from a function
  28. How to execute cargo test using the nightly channel?
  29. How do I add days to a Chrono UTC?
  30. Understanding the Send trait
  31. What is the bitwise NOT operator in Rust?
  32. How do I convert an enum reference to a number?
  33. Dividing two integers doesn’t print as a decimal number in Rust
  34. How do I return a reference to something inside a RefCell without breaking encapsulation?
  35. Is there a way other than traits to add methods to a type I don’t own?
  36. How to disable a clippy lint for a single line / block? [duplicate]
  37. When would you use a Mutex without an Arc?
  38. Sort HashMap data by value
  39. What is the difference between `|_| async move {}` and `async move |_| {}`
  40. How can I swap in a new value for a field in a mutable reference to a structure?
  41. What is the null pointer optimization in Rust?
  42. Why do Rust programs use so much more memory than the C, Haskell and OCaml versions?
  43. Why does Rust not have unions?
  44. How do you document function arguments?
  45. Can’t use `-Z macro-backtrace` unstable option with `cargo`
  46. Cannot borrow `x` as mutable more than once at a time
  47. How do I convert a Vec to Result? [duplicate]
  48. Implementing a trait for multiple types at once
  49. Why is std::rc::Rc not Copy?
  50. Idiomatic way of assigning a value from an if else condition in Rust

Leave a Comment