mirror of https://github.com/Dhghomon/easy_rust
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
499 lines
32 KiB
HTML
499 lines
32 KiB
HTML
<!DOCTYPE HTML>
|
|
<html lang="en" class="sidebar-visible no-js light">
|
|
<head>
|
|
<!-- Book generated using mdBook -->
|
|
<meta charset="UTF-8">
|
|
<title> Interior mutability - Easy Rust</title>
|
|
|
|
|
|
<!-- Custom HTML head -->
|
|
|
|
|
|
<meta content="text/html; charset=utf-8" http-equiv="Content-Type">
|
|
<meta name="description" content="">
|
|
<meta name="viewport" content="width=device-width, initial-scale=1">
|
|
<meta name="theme-color" content="#ffffff" />
|
|
|
|
<link rel="icon" href="favicon.svg">
|
|
<link rel="shortcut icon" href="favicon.png">
|
|
<link rel="stylesheet" href="css/variables.css">
|
|
<link rel="stylesheet" href="css/general.css">
|
|
<link rel="stylesheet" href="css/chrome.css">
|
|
<link rel="stylesheet" href="css/print.css" media="print">
|
|
|
|
<!-- Fonts -->
|
|
<link rel="stylesheet" href="FontAwesome/css/font-awesome.css">
|
|
<link rel="stylesheet" href="fonts/fonts.css">
|
|
|
|
<!-- Highlight.js Stylesheets -->
|
|
<link rel="stylesheet" href="highlight.css">
|
|
<link rel="stylesheet" href="tomorrow-night.css">
|
|
<link rel="stylesheet" href="ayu-highlight.css">
|
|
|
|
<!-- Custom theme stylesheets -->
|
|
|
|
</head>
|
|
<body>
|
|
<!-- Provide site root to javascript -->
|
|
<script type="text/javascript">
|
|
var path_to_root = "";
|
|
var default_theme = window.matchMedia("(prefers-color-scheme: dark)").matches ? "navy" : "light";
|
|
</script>
|
|
|
|
<!-- Work around some values being stored in localStorage wrapped in quotes -->
|
|
<script type="text/javascript">
|
|
try {
|
|
var theme = localStorage.getItem('mdbook-theme');
|
|
var sidebar = localStorage.getItem('mdbook-sidebar');
|
|
|
|
if (theme.startsWith('"') && theme.endsWith('"')) {
|
|
localStorage.setItem('mdbook-theme', theme.slice(1, theme.length - 1));
|
|
}
|
|
|
|
if (sidebar.startsWith('"') && sidebar.endsWith('"')) {
|
|
localStorage.setItem('mdbook-sidebar', sidebar.slice(1, sidebar.length - 1));
|
|
}
|
|
} catch (e) { }
|
|
</script>
|
|
|
|
<!-- Set the theme before any content is loaded, prevents flash -->
|
|
<script type="text/javascript">
|
|
var theme;
|
|
try { theme = localStorage.getItem('mdbook-theme'); } catch(e) { }
|
|
if (theme === null || theme === undefined) { theme = default_theme; }
|
|
var html = document.querySelector('html');
|
|
html.classList.remove('no-js')
|
|
html.classList.remove('light')
|
|
html.classList.add(theme);
|
|
html.classList.add('js');
|
|
</script>
|
|
|
|
<!-- Hide / unhide sidebar before it is displayed -->
|
|
<script type="text/javascript">
|
|
var html = document.querySelector('html');
|
|
var sidebar = 'hidden';
|
|
if (document.body.clientWidth >= 1080) {
|
|
try { sidebar = localStorage.getItem('mdbook-sidebar'); } catch(e) { }
|
|
sidebar = sidebar || 'visible';
|
|
}
|
|
html.classList.remove('sidebar-visible');
|
|
html.classList.add("sidebar-" + sidebar);
|
|
</script>
|
|
|
|
<nav id="sidebar" class="sidebar" aria-label="Table of contents">
|
|
<div class="sidebar-scrollbox">
|
|
<ol class="chapter"><li class="chapter-item expanded "><a href="Chapter_0.html"><strong aria-hidden="true">1.</strong> Updates</a></li><li class="chapter-item expanded "><a href="Chapter_1.html"><strong aria-hidden="true">2.</strong> Introduction</a></li><li class="chapter-item expanded "><a href="Chapter_2.html"><strong aria-hidden="true">3.</strong> Who am I?</a></li><li class="chapter-item expanded "><a href="Chapter_3.html"><strong aria-hidden="true">4.</strong> Writing Rust in Easy English</a></li><li class="chapter-item expanded "><a href="Chapter_4.html"><strong aria-hidden="true">5.</strong> Rust Playground</a></li><li class="chapter-item expanded "><a href="Chapter_5.html"><strong aria-hidden="true">6.</strong> 🚧 and ⚠️</a></li><li class="chapter-item expanded "><a href="Chapter_6.html"><strong aria-hidden="true">7.</strong> Comments</a></li><li class="chapter-item expanded "><a href="Chapter_7.html"><strong aria-hidden="true">8.</strong> Types</a></li><li class="chapter-item expanded "><a href="Chapter_8.html"><strong aria-hidden="true">9.</strong> Type inference</a></li><li class="chapter-item expanded "><a href="Chapter_9.html"><strong aria-hidden="true">10.</strong> Printing 'hello, world!'</a></li><li class="chapter-item expanded "><a href="Chapter_10.html"><strong aria-hidden="true">11.</strong> Display and debug</a></li><li class="chapter-item expanded "><a href="Chapter_11.html"><strong aria-hidden="true">12.</strong> Mutability (changing)</a></li><li class="chapter-item expanded "><a href="Chapter_12.html"><strong aria-hidden="true">13.</strong> The stack, the heap, and pointers</a></li><li class="chapter-item expanded "><a href="Chapter_13.html"><strong aria-hidden="true">14.</strong> More about printing</a></li><li class="chapter-item expanded "><a href="Chapter_14.html"><strong aria-hidden="true">15.</strong> Strings</a></li><li class="chapter-item expanded "><a href="Chapter_15.html"><strong aria-hidden="true">16.</strong> const and static</a></li><li class="chapter-item expanded "><a href="Chapter_16.html"><strong aria-hidden="true">17.</strong> More on references</a></li><li class="chapter-item expanded "><a href="Chapter_17.html"><strong aria-hidden="true">18.</strong> Mutable references</a></li><li class="chapter-item expanded "><a href="Chapter_18.html"><strong aria-hidden="true">19.</strong> Giving references to functions</a></li><li class="chapter-item expanded "><a href="Chapter_19.html"><strong aria-hidden="true">20.</strong> Copy types</a></li><li class="chapter-item expanded "><a href="Chapter_20.html"><strong aria-hidden="true">21.</strong> Collection types</a></li><li class="chapter-item expanded "><a href="Chapter_21.html"><strong aria-hidden="true">22.</strong> Vectors</a></li><li class="chapter-item expanded "><a href="Chapter_22.html"><strong aria-hidden="true">23.</strong> Tuples</a></li><li class="chapter-item expanded "><a href="Chapter_23.html"><strong aria-hidden="true">24.</strong> Control flow</a></li><li class="chapter-item expanded "><a href="Chapter_24.html"><strong aria-hidden="true">25.</strong> Structs</a></li><li class="chapter-item expanded "><a href="Chapter_25.html"><strong aria-hidden="true">26.</strong> Enums</a></li><li class="chapter-item expanded "><a href="Chapter_26.html"><strong aria-hidden="true">27.</strong> Loops</a></li><li class="chapter-item expanded "><a href="Chapter_27.html"><strong aria-hidden="true">28.</strong> Implementing structs and enums</a></li><li class="chapter-item expanded "><a href="Chapter_28.html"><strong aria-hidden="true">29.</strong> Destructuring</a></li><li class="chapter-item expanded "><a href="Chapter_29.html"><strong aria-hidden="true">30.</strong> References and the dot operator</a></li><li class="chapter-item expanded "><a href="Chapter_30.html"><strong aria-hidden="true">31.</strong> Generics</a></li><li class="chapter-item expanded "><a href="Chapter_31.html"><strong aria-hidden="true">32.</strong> Option and Result</a></li><li class="chapter-item expanded "><a href="Chapter_32.html"><strong aria-hidden="true">33.</strong> Other collections</a></li><li class="chapter-item expanded "><a href="Chapter_33.html"><strong aria-hidden="true">34.</strong> The ? operator</a></li><li class="chapter-item expanded "><a href="Chapter_34.html"><strong aria-hidden="true">35.</strong> Traits</a></li><li class="chapter-item expanded "><a href="Chapter_35.html"><strong aria-hidden="true">36.</strong> Chaining methods</a></li><li class="chapter-item expanded "><a href="Chapter_36.html"><strong aria-hidden="true">37.</strong> Iterators</a></li><li class="chapter-item expanded "><a href="Chapter_37.html"><strong aria-hidden="true">38.</strong> Closures</a></li><li class="chapter-item expanded "><a href="Chapter_38.html"><strong aria-hidden="true">39.</strong> The dbg! macro and .inspect</a></li><li class="chapter-item expanded "><a href="Chapter_39.html"><strong aria-hidden="true">40.</strong> Types of &str</a></li><li class="chapter-item expanded "><a href="Chapter_40.html"><strong aria-hidden="true">41.</strong> Lifetimes</a></li><li class="chapter-item expanded "><a href="Chapter_41.html" class="active"><strong aria-hidden="true">42.</strong> Interior mutability</a></li><li class="chapter-item expanded "><a href="Chapter_42.html"><strong aria-hidden="true">43.</strong> Cow</a></li><li class="chapter-item expanded "><a href="Chapter_43.html"><strong aria-hidden="true">44.</strong> Type aliases</a></li><li class="chapter-item expanded "><a href="Chapter_44.html"><strong aria-hidden="true">45.</strong> The todo! macro</a></li><li class="chapter-item expanded "><a href="Chapter_45.html"><strong aria-hidden="true">46.</strong> Rc</a></li><li class="chapter-item expanded "><a href="Chapter_46.html"><strong aria-hidden="true">47.</strong> Multiple threads</a></li><li class="chapter-item expanded "><a href="Chapter_47.html"><strong aria-hidden="true">48.</strong> Closures in functions</a></li><li class="chapter-item expanded "><a href="Chapter_48.html"><strong aria-hidden="true">49.</strong> impl Trait</a></li><li class="chapter-item expanded "><a href="Chapter_49.html"><strong aria-hidden="true">50.</strong> Arc</a></li><li class="chapter-item expanded "><a href="Chapter_50.html"><strong aria-hidden="true">51.</strong> Channels</a></li><li class="chapter-item expanded "><a href="Chapter_51.html"><strong aria-hidden="true">52.</strong> Reading Rust documentation</a></li><li class="chapter-item expanded "><a href="Chapter_52.html"><strong aria-hidden="true">53.</strong> Attributes</a></li><li class="chapter-item expanded "><a href="Chapter_53.html"><strong aria-hidden="true">54.</strong> Box</a></li><li class="chapter-item expanded "><a href="Chapter_54.html"><strong aria-hidden="true">55.</strong> Box around traits</a></li><li class="chapter-item expanded "><a href="Chapter_55.html"><strong aria-hidden="true">56.</strong> Default and the builder pattern</a></li><li class="chapter-item expanded "><a href="Chapter_56.html"><strong aria-hidden="true">57.</strong> Deref and DerefMut</a></li><li class="chapter-item expanded "><a href="Chapter_57.html"><strong aria-hidden="true">58.</strong> Crates and modules</a></li><li class="chapter-item expanded "><a href="Chapter_58.html"><strong aria-hidden="true">59.</strong> Testing</a></li><li class="chapter-item expanded "><a href="Chapter_59.html"><strong aria-hidden="true">60.</strong> External crates</a></li><li class="chapter-item expanded "><a href="Chapter_60.html"><strong aria-hidden="true">61.</strong> A tour of the standard library</a></li><li class="chapter-item expanded "><a href="Chapter_61.html"><strong aria-hidden="true">62.</strong> Writing macros</a></li><li class="chapter-item expanded "><a href="Chapter_62.html"><strong aria-hidden="true">63.</strong> cargo</a></li><li class="chapter-item expanded "><a href="Chapter_63.html"><strong aria-hidden="true">64.</strong> Taking user input</a></li><li class="chapter-item expanded "><a href="Chapter_64.html"><strong aria-hidden="true">65.</strong> Using files</a></li><li class="chapter-item expanded "><a href="Chapter_65.html"><strong aria-hidden="true">66.</strong> cargo doc</a></li><li class="chapter-item expanded "><a href="Chapter_66.html"><strong aria-hidden="true">67.</strong> The end?</a></li></ol> </div>
|
|
<div id="sidebar-resize-handle" class="sidebar-resize-handle"></div>
|
|
</nav>
|
|
|
|
<div id="page-wrapper" class="page-wrapper">
|
|
|
|
<div class="page">
|
|
|
|
<div id="menu-bar-hover-placeholder"></div>
|
|
<div id="menu-bar" class="menu-bar sticky bordered">
|
|
<div class="left-buttons">
|
|
<button id="sidebar-toggle" class="icon-button" type="button" title="Toggle Table of Contents" aria-label="Toggle Table of Contents" aria-controls="sidebar">
|
|
<i class="fa fa-bars"></i>
|
|
</button>
|
|
<button id="theme-toggle" class="icon-button" type="button" title="Change theme" aria-label="Change theme" aria-haspopup="true" aria-expanded="false" aria-controls="theme-list">
|
|
<i class="fa fa-paint-brush"></i>
|
|
</button>
|
|
<ul id="theme-list" class="theme-popup" aria-label="Themes" role="menu">
|
|
<li role="none"><button role="menuitem" class="theme" id="light">Light (default)</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="rust">Rust</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="coal">Coal</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="navy">Navy</button></li>
|
|
<li role="none"><button role="menuitem" class="theme" id="ayu">Ayu</button></li>
|
|
</ul>
|
|
<button id="search-toggle" class="icon-button" type="button" title="Search. (Shortkey: s)" aria-label="Toggle Searchbar" aria-expanded="false" aria-keyshortcuts="S" aria-controls="searchbar">
|
|
<i class="fa fa-search"></i>
|
|
</button>
|
|
</div>
|
|
|
|
<h1 class="menu-title">Easy Rust</h1>
|
|
|
|
<div class="right-buttons">
|
|
<a href="print.html" title="Print this book" aria-label="Print this book">
|
|
<i id="print-button" class="fa fa-print"></i>
|
|
</a>
|
|
|
|
</div>
|
|
</div>
|
|
|
|
<div id="search-wrapper" class="hidden">
|
|
<form id="searchbar-outer" class="searchbar-outer">
|
|
<input type="search" id="searchbar" name="searchbar" placeholder="Search this book ..." aria-controls="searchresults-outer" aria-describedby="searchresults-header">
|
|
</form>
|
|
<div id="searchresults-outer" class="searchresults-outer hidden">
|
|
<div id="searchresults-header" class="searchresults-header"></div>
|
|
<ul id="searchresults">
|
|
</ul>
|
|
</div>
|
|
</div>
|
|
|
|
<!-- Apply ARIA attributes after the sidebar and the sidebar toggle button are added to the DOM -->
|
|
<script type="text/javascript">
|
|
document.getElementById('sidebar-toggle').setAttribute('aria-expanded', sidebar === 'visible');
|
|
document.getElementById('sidebar').setAttribute('aria-hidden', sidebar !== 'visible');
|
|
Array.from(document.querySelectorAll('#sidebar a')).forEach(function(link) {
|
|
link.setAttribute('tabIndex', sidebar === 'visible' ? 0 : -1);
|
|
});
|
|
</script>
|
|
|
|
<div id="content" class="content">
|
|
<main>
|
|
<h2 id="interior-mutability"><a class="header" href="#interior-mutability">Interior mutability</a></h2>
|
|
<h3 id="cell"><a class="header" href="#cell">Cell</a></h3>
|
|
<p><strong>Interior mutability</strong> means having a little bit of mutability on the inside. Remember how in Rust you need to use <code>mut</code> to change a variable? There are also some ways to change them without the word <code>mut</code>. This is because Rust has some ways to let you safely change values inside of a struct that is immutable. Each one of them follows some rules that make sure that changing the values is still safe.</p>
|
|
<p>First, let's look at a simple example where we would want this. Imagine a <code>struct</code> called <code>PhoneModel</code> with many fields:</p>
|
|
<pre><pre class="playground"><code class="language-rust">struct PhoneModel {
|
|
company_name: String,
|
|
model_name: String,
|
|
screen_size: f32,
|
|
memory: usize,
|
|
date_issued: u32,
|
|
on_sale: bool,
|
|
}
|
|
|
|
fn main() {
|
|
let super_phone_3000 = PhoneModel {
|
|
company_name: "YY Electronics".to_string(),
|
|
model_name: "Super Phone 3000".to_string(),
|
|
screen_size: 7.5,
|
|
memory: 4_000_000,
|
|
date_issued: 2020,
|
|
on_sale: true,
|
|
};
|
|
|
|
}
|
|
</code></pre></pre>
|
|
<p>It is better for the fields in <code>PhoneModel</code> to be immutable, because we don't want the data to change. The <code>date_issued</code> and <code>screen_size</code> never change, for example.</p>
|
|
<p>But inside is one field called <code>on_sale</code>. A phone model will first be on sale (<code>true</code>), but later the company will stop selling it. Can we make just this one field mutable? Because we don't want to write <code>let mut super_phone_3000</code>. If we do, then every field will become mutable.</p>
|
|
<p>Rust has many ways to allow some safe mutability inside of something that is immutable. The most simple way is called <code>Cell</code>. First we use <code>use std::cell::Cell</code> so that we can just write <code>Cell</code> instead of <code>std::cell::Cell</code> every time.</p>
|
|
<p>Then we change <code>on_sale: bool</code> to <code>on_sale: Cell<bool></code>. Now it isn't a bool: it's a <code>Cell</code> that holds a <code>bool</code>.</p>
|
|
<p><code>Cell</code> has a method called <code>.set()</code> where you can change the value. We use <code>.set()</code> to change <code>on_sale: true</code> to <code>on_sale: Cell::new(true)</code>.</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::cell::Cell;
|
|
|
|
struct PhoneModel {
|
|
company_name: String,
|
|
model_name: String,
|
|
screen_size: f32,
|
|
memory: usize,
|
|
date_issued: u32,
|
|
on_sale: Cell<bool>,
|
|
}
|
|
|
|
fn main() {
|
|
let super_phone_3000 = PhoneModel {
|
|
company_name: "YY Electronics".to_string(),
|
|
model_name: "Super Phone 3000".to_string(),
|
|
screen_size: 7.5,
|
|
memory: 4_000_000,
|
|
date_issued: 2020,
|
|
on_sale: Cell::new(true),
|
|
};
|
|
|
|
// 10 years later, super_phone_3000 is not on sale anymore
|
|
super_phone_3000.on_sale.set(false);
|
|
}
|
|
</code></pre></pre>
|
|
<p><code>Cell</code> works for all types, but works best for simple Copy types because it gives values, not references. <code>Cell</code> has a method called <code>get()</code> for example that only works on Copy types.</p>
|
|
<p>Another type you can use is <code>RefCell</code>.</p>
|
|
<h3 id="refcell"><a class="header" href="#refcell">RefCell</a></h3>
|
|
<p>A <code>RefCell</code> is another way to change values without needing to declare <code>mut</code>. It means "reference cell", and is like a <code>Cell</code> but uses references instead of copies.</p>
|
|
<p>We will create a <code>User</code> struct. So far you can see that it is similar to <code>Cell</code>:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::cell::RefCell;
|
|
|
|
#[derive(Debug)]
|
|
struct User {
|
|
id: u32,
|
|
year_registered: u32,
|
|
username: String,
|
|
active: RefCell<bool>,
|
|
// Many other fields
|
|
}
|
|
|
|
fn main() {
|
|
let user_1 = User {
|
|
id: 1,
|
|
year_registered: 2020,
|
|
username: "User 1".to_string(),
|
|
active: RefCell::new(true),
|
|
};
|
|
|
|
println!("{:?}", user_1.active);
|
|
}
|
|
</code></pre></pre>
|
|
<p>This prints <code>RefCell { value: true }</code>.</p>
|
|
<p>There are many methods for <code>RefCell</code>. Two of them are <code>.borrow()</code> and <code>.borrow_mut()</code>. With these methods, you can do the same thing you do with <code>&</code> and <code>&mut</code>. The rules are the same:</p>
|
|
<ul>
|
|
<li>Many borrows is fine,</li>
|
|
<li>one mutable borrow is fine,</li>
|
|
<li>but mutable and immutable together is not fine.</li>
|
|
</ul>
|
|
<p>So changing the value in a <code>RefCell</code> is very easy:</p>
|
|
<pre><pre class="playground"><code class="language-rust">
|
|
<span class="boring">#![allow(unused)]
|
|
</span><span class="boring">fn main() {
|
|
</span>// 🚧
|
|
user_1.active.replace(false);
|
|
println!("{:?}", user_1.active);
|
|
<span class="boring">}
|
|
</span></code></pre></pre>
|
|
<p>And there are many other methods like <code>replace_with</code> that uses a closure:</p>
|
|
<pre><pre class="playground"><code class="language-rust">
|
|
<span class="boring">#![allow(unused)]
|
|
</span><span class="boring">fn main() {
|
|
</span>// 🚧
|
|
let date = 2020;
|
|
|
|
user_1
|
|
.active
|
|
.replace_with(|_| if date < 2000 { true } else { false });
|
|
println!("{:?}", user_1.active);
|
|
<span class="boring">}
|
|
</span></code></pre></pre>
|
|
<p>But you have to be careful with a <code>RefCell</code>, because it checks borrows at runtime, not compilation time. Runtime means when the program is actually running (after compilation). So this will compile, even though it is wrong:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::cell::RefCell;
|
|
|
|
#[derive(Debug)]
|
|
struct User {
|
|
id: u32,
|
|
year_registered: u32,
|
|
username: String,
|
|
active: RefCell<bool>,
|
|
// Many other fields
|
|
}
|
|
|
|
fn main() {
|
|
let user_1 = User {
|
|
id: 1,
|
|
year_registered: 2020,
|
|
username: "User 1".to_string(),
|
|
active: RefCell::new(true),
|
|
};
|
|
|
|
let borrow_one = user_1.active.borrow_mut(); // first mutable borrow - okay
|
|
let borrow_two = user_1.active.borrow_mut(); // second mutable borrow - not okay
|
|
}
|
|
</code></pre></pre>
|
|
<p>But if you run it, it will immediately panic.</p>
|
|
<pre><code class="language-text">thread 'main' panicked at 'already borrowed: BorrowMutError', C:\Users\mithr\.rustup\toolchains\stable-x86_64-pc-windows-msvc\lib/rustlib/src/rust\src\libcore\cell.rs:877:9
|
|
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
|
|
error: process didn't exit successfully: `target\debug\rust_book.exe` (exit code: 101)
|
|
</code></pre>
|
|
<p><code>already borrowed: BorrowMutError</code> is the important part. So when you use a <code>RefCell</code>, it is good to compile <strong>and</strong> run to check.</p>
|
|
<h3 id="mutex"><a class="header" href="#mutex">Mutex</a></h3>
|
|
<p><code>Mutex</code> is another way to change values without declaring <code>mut</code>. Mutex means <code>mutual exclusion</code>, which means "only one at a time". This is why a <code>Mutex</code> is safe, because it only lets one process change it at a time. To do this, it uses <code>.lock()</code>. <code>Lock</code> is like locking a door from the inside. You go into a room, lock the door, and now you can change things inside the room. Nobody else can come in and stop you, because you locked the door.</p>
|
|
<p>A <code>Mutex</code> is easier to understand through examples.</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5); // A new Mutex<i32>. We don't need to say mut
|
|
let mut mutex_changer = my_mutex.lock().unwrap(); // mutex_changer is a MutexGuard
|
|
// It has to be mut because we will change it
|
|
// Now it has access to the Mutex
|
|
// Let's print my_mutex to see:
|
|
|
|
println!("{:?}", my_mutex); // This prints "Mutex { data: <locked> }"
|
|
// So we can't access the data with my_mutex now,
|
|
// only with mutex_changer
|
|
|
|
println!("{:?}", mutex_changer); // This prints 5. Let's change it to 6.
|
|
|
|
*mutex_changer = 6; // mutex_changer is a MutexGuard<i32> so we use * to change the i32
|
|
|
|
println!("{:?}", mutex_changer); // Now it says 6
|
|
}
|
|
</code></pre></pre>
|
|
<p>But <code>mutex_changer</code> still has a lock after it is done. How do we stop it? A <code>Mutex</code> is unlocked when the <code>MutexGuard</code> goes out of scope. "Go out of scope" means the code block is finished. For example:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
{
|
|
let mut mutex_changer = my_mutex.lock().unwrap();
|
|
*mutex_changer = 6;
|
|
} // mutex_changer goes out of scope - now it is gone. It is not locked anymore
|
|
|
|
println!("{:?}", my_mutex); // Now it says: Mutex { data: 6 }
|
|
}
|
|
</code></pre></pre>
|
|
<p>If you don't want to use a different <code>{}</code> code block, you can use <code>std::mem::drop(mutex_changer)</code>. <code>std::mem::drop</code> means "make this go out of scope".</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
let mut mutex_changer = my_mutex.lock().unwrap();
|
|
*mutex_changer = 6;
|
|
std::mem::drop(mutex_changer); // drop mutex_changer - it is gone now
|
|
// and my_mutex is unlocked
|
|
|
|
println!("{:?}", my_mutex); // Now it says: Mutex { data: 6 }
|
|
}
|
|
</code></pre></pre>
|
|
<p>You have to be careful with a <code>Mutex</code> because if another variable tries to <code>lock</code> it, it will wait:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
let mut mutex_changer = my_mutex.lock().unwrap(); // mutex_changer has the lock
|
|
let mut other_mutex_changer = my_mutex.lock().unwrap(); // other_mutex_changer wants the lock
|
|
// the program is waiting
|
|
// and waiting
|
|
// and will wait forever.
|
|
|
|
println!("This will never print...");
|
|
}
|
|
</code></pre></pre>
|
|
<p>One other method is <code>try_lock()</code>. Then it will try once, and if it doesn't get the lock it will give up. Don't do <code>try_lock().unwrap()</code>, because it will panic if it doesn't work. <code>if let</code> or <code>match</code> is better:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
let mut mutex_changer = my_mutex.lock().unwrap();
|
|
let mut other_mutex_changer = my_mutex.try_lock(); // try to get the lock
|
|
|
|
if let Ok(value) = other_mutex_changer {
|
|
println!("The MutexGuard has: {}", value)
|
|
} else {
|
|
println!("Didn't get the lock")
|
|
}
|
|
}
|
|
</code></pre></pre>
|
|
<p>Also, you don't need to make a variable to change the <code>Mutex</code>. You can just do this:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
|
|
*my_mutex.lock().unwrap() = 6;
|
|
|
|
println!("{:?}", my_mutex);
|
|
}
|
|
</code></pre></pre>
|
|
<p><code>*my_mutex.lock().unwrap() = 6;</code> means "unlock my_mutex and make it 6". There is no variable that holds it so you don't need to call <code>std::mem::drop</code>. You can do it 100 times if you want - it doesn't matter:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::Mutex;
|
|
|
|
fn main() {
|
|
let my_mutex = Mutex::new(5);
|
|
|
|
for _ in 0..100 {
|
|
*my_mutex.lock().unwrap() += 1; // locks and unlocks 100 times
|
|
}
|
|
|
|
println!("{:?}", my_mutex);
|
|
}
|
|
</code></pre></pre>
|
|
<h3 id="rwlock"><a class="header" href="#rwlock">RwLock</a></h3>
|
|
<p><code>RwLock</code> means "read write lock". It is like a <code>Mutex</code> but also like a <code>RefCell</code>. You use <code>.write().unwrap()</code> instead of <code>.lock().unwrap()</code> to change it. But you can also use <code>.read().unwrap()</code> to get read access. It is like <code>RefCell</code> because it follows the rules:</p>
|
|
<ul>
|
|
<li>many <code>.read()</code> variables is okay,</li>
|
|
<li>one <code>.write()</code> variable is okay,</li>
|
|
<li>but more than one <code>.write()</code> or <code>.read()</code> together with <code>.write()</code> is not okay.</li>
|
|
</ul>
|
|
<p>The program will run forever if you try to <code>.write()</code> when you can't get access:</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::RwLock;
|
|
|
|
fn main() {
|
|
let my_rwlock = RwLock::new(5);
|
|
|
|
let read1 = my_rwlock.read().unwrap(); // one .read() is fine
|
|
let read2 = my_rwlock.read().unwrap(); // two .read()s is also fine
|
|
|
|
println!("{:?}, {:?}", read1, read2);
|
|
|
|
let write1 = my_rwlock.write().unwrap(); // uh oh, now the program will wait forever
|
|
}
|
|
</code></pre></pre>
|
|
<p>So we use <code>std::mem::drop</code>, just like in a <code>Mutex</code>.</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::RwLock;
|
|
use std::mem::drop; // We will use drop() many times
|
|
|
|
fn main() {
|
|
let my_rwlock = RwLock::new(5);
|
|
|
|
let read1 = my_rwlock.read().unwrap();
|
|
let read2 = my_rwlock.read().unwrap();
|
|
|
|
println!("{:?}, {:?}", read1, read2);
|
|
|
|
drop(read1);
|
|
drop(read2); // we dropped both, so we can use .write() now
|
|
|
|
let mut write1 = my_rwlock.write().unwrap();
|
|
*write1 = 6;
|
|
drop(write1);
|
|
println!("{:?}", my_rwlock);
|
|
}
|
|
</code></pre></pre>
|
|
<p>And you can use <code>try_read()</code> and <code>try_write()</code> too.</p>
|
|
<pre><pre class="playground"><code class="language-rust">use std::sync::RwLock;
|
|
|
|
fn main() {
|
|
let my_rwlock = RwLock::new(5);
|
|
|
|
let read1 = my_rwlock.read().unwrap();
|
|
let read2 = my_rwlock.read().unwrap();
|
|
|
|
if let Ok(mut number) = my_rwlock.try_write() {
|
|
*number += 10;
|
|
println!("Now the number is {}", number);
|
|
} else {
|
|
println!("Couldn't get write access, sorry!")
|
|
};
|
|
}
|
|
</code></pre></pre>
|
|
|
|
</main>
|
|
|
|
<nav class="nav-wrapper" aria-label="Page navigation">
|
|
<!-- Mobile navigation buttons -->
|
|
<a rel="prev" href="Chapter_40.html" class="mobile-nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
|
|
<i class="fa fa-angle-left"></i>
|
|
</a>
|
|
|
|
<a rel="next" href="Chapter_42.html" class="mobile-nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
|
|
<i class="fa fa-angle-right"></i>
|
|
</a>
|
|
|
|
<div style="clear: both"></div>
|
|
</nav>
|
|
</div>
|
|
</div>
|
|
|
|
<nav class="nav-wide-wrapper" aria-label="Page navigation">
|
|
<a rel="prev" href="Chapter_40.html" class="nav-chapters previous" title="Previous chapter" aria-label="Previous chapter" aria-keyshortcuts="Left">
|
|
<i class="fa fa-angle-left"></i>
|
|
</a>
|
|
|
|
<a rel="next" href="Chapter_42.html" class="nav-chapters next" title="Next chapter" aria-label="Next chapter" aria-keyshortcuts="Right">
|
|
<i class="fa fa-angle-right"></i>
|
|
</a>
|
|
</nav>
|
|
|
|
</div>
|
|
|
|
|
|
|
|
|
|
<script type="text/javascript">
|
|
window.playground_copyable = true;
|
|
</script>
|
|
|
|
|
|
<script src="elasticlunr.min.js" type="text/javascript" charset="utf-8"></script>
|
|
<script src="mark.min.js" type="text/javascript" charset="utf-8"></script>
|
|
<script src="searcher.js" type="text/javascript" charset="utf-8"></script>
|
|
|
|
<script src="clipboard.min.js" type="text/javascript" charset="utf-8"></script>
|
|
<script src="highlight.js" type="text/javascript" charset="utf-8"></script>
|
|
<script src="book.js" type="text/javascript" charset="utf-8"></script>
|
|
|
|
<!-- Custom JS scripts -->
|
|
|
|
|
|
</body>
|
|
</html>
|