X-Git-Url: https://git.ralfj.de/rust-101.git/blobdiff_plain/98dafe0138b8bf6584b8d9e86a74a580bb034a26..188b1ec1b8528e2326791feccc8077e15bd60182:/workspace/src/part15.rs diff --git a/workspace/src/part15.rs b/workspace/src/part15.rs index 4dca116..d006b23 100644 --- a/workspace/src/part15.rs +++ b/workspace/src/part15.rs @@ -1,4 +1,76 @@ -// Rust-101, Part 15: Interior Mutability (cont.), RefCell, Cell, Drop -// =================================================================== +// Rust-101, Part 15: Mutex, Interior Mutability (cont.), Sync +// =========================================================== + +use std::sync::{Arc, Mutex}; +use std::thread; + + +// The derived `Clone` implementation will clone the `Arc`, so all clones will actually talk about the same counter. +#[derive(Clone)] +struct ConcurrentCounter(Arc>); + +impl ConcurrentCounter { + // The constructor just wraps the constructors of `Arc` and `Mutex`. + pub fn new(val: usize) -> Self { + unimplemented!() + } + + pub fn increment(&self, by: usize) { + // `lock` on a mutex returns a *guard*, giving access to the data contained in the mutex. + let mut counter = self.0.lock().unwrap(); + *counter = *counter + by; + } + + // The function `get` returns the current value of the counter. + pub fn get(&self) -> usize { + unimplemented!() + } +} + +// Now our counter is ready for action. +pub fn main() { + let counter = ConcurrentCounter::new(0); + + // We clone the counter for the first thread, which increments it by 2 every 15ms. + let counter1 = counter.clone(); + let handle1 = thread::spawn(move || { + for _ in 0..10 { + thread::sleep_ms(15); + counter1.increment(2); + } + }); + + // The second thread increments the counter by 3 every 20ms. + let counter2 = counter.clone(); + let handle2 = thread::spawn(move || { + for _ in 0..10 { + thread::sleep_ms(20); + counter2.increment(3); + } + }); + + // Now we watch the threads working on the counter. + for _ in 0..50 { + thread::sleep_ms(5); + println!("Current value: {}", counter.get()); + } + + // Finally, we wait for all the threads to finish to be sure we can catch the counter's final value. + handle1.join().unwrap(); + handle2.join().unwrap(); + println!("Final value: {}", counter.get()); +} + +// **Exercise 14.1**: Besides `Mutex`, there's also [`RwLock`](http://doc.rust-lang.org/stable/std/sync/struct.RwLock.html), which +// provides two ways of locking: One that grants only read-only access, to any number of concurrent readers, and another one +// for exclusive write access. (Notice that this is the same pattern we already saw with shared vs. mutable borrows.) Change +// the code above to use `RwLock`, such that multiple calls to `get` can be executed at the same time. +// +// **Exercise 14.2**: Add an operation `compare_and_inc(&self, test: usize, by: usize)` that increments the counter by +// `by` *only if* the current value is `test`. + + +// FIXME TODO some old outdated explanation FIXME TODO +