RwLock<T>

Use a many-reader single-writer lock with RwLock<T>.

RwLock<T>

RwLock<T> is the cross-thread version of the borrowing rules: at any time many readers (read()) or one writer (write()). For data read far more often than written (settings, caches), it's more efficient than a Mutex:

use std::sync::{Arc, RwLock};

let kayit = Arc::new(RwLock::new(Vec::new()));
kayit.write().unwrap().push(String::from("açılış"));
let adet = kayit.read().unwrap().len();

Readers don't block each other; a writer waits for all readers to finish.

Reader threads

Each reader reads with its own Arc copy; the read guard is held briefly inside the thread:

let tutucular: Vec<_> = (0..3)
    .map(|_| {
        let k = Arc::clone(&kayit);
        thread::spawn(move || k.read().unwrap().len())
    })
    .collect();
let uzunluklar: Vec<usize> = tutucular.into_iter().map(|h| h.join().unwrap()).collect();

Exercise Many readers

Create an Arc<RwLock<Vec<String>>> and add two records with write. Start three reader threads; let each return the length with read. Collect the results in order and print them.

Show example solution

use std::sync::{Arc, RwLock};
use std::thread;

fn main() {
    let kayit = Arc::new(RwLock::new(Vec::new()));
    kayit.write().unwrap().push(String::from("açılış"));
    kayit.write().unwrap().push(String::from("giriş"));
    let tutucular: Vec<_> = (0..3)
        .map(|_| {
            let k = Arc::clone(&kayit);
            thread::spawn(move || k.read().unwrap().len())
        })
        .collect();
    let uzunluklar: Vec<usize> = tutucular.into_iter().map(|h| h.join().unwrap()).collect();
    println!("{:?}", uzunluklar);
}

Test yourself

If writes are almost as frequent as reads, which is usually better?
- Cell
- Mutex; RwLock's extra bookkeeping cancels the gain
- RwLock always
- Neither can be used
Show answer

Mutex; RwLock's extra bookkeeping cancels the gain — RwLock must track the reader count; if reads don't dominate, a simple Mutex is faster. Don't decide without measuring.

Write lock

kayit.____().unwrap().push(String::from("açılış"));

Show answer

kayit.write().unwrap().push(String::from("açılış"));

Method and access

read()

Shared read
write()

Exclusive write
Mutex::lock()

Every access exclusive
try_read()

Try without waiting

Next lesson: Arc<T>

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies