solutions/src/counter.rs

   1 use std::sync::{Arc, RwLock};
   2 use std::thread;
   3 use std::time::Duration;
   4
   5 #[derive(Clone)]
   6 pub struct ConcurrentCounter(Arc<RwLock<usize>>);
   7
   8 impl ConcurrentCounter {
   9     // The constructor should not be surprising.
  10     pub fn new(val: usize) -> Self {
  11         ConcurrentCounter(Arc::new(RwLock::new(val)))
  12     }
  13
  14     pub fn increment(&self, by: usize) {
  15         let mut counter = self.0.write().unwrap_or_else(|e| e.into_inner());
  16         *counter = *counter + by;
  17     }
  18
  19     pub fn compare_and_inc(&self, test: usize, by: usize) {
  20         let mut counter = self.0.write().unwrap_or_else(|e| e.into_inner());
  21         if *counter == test {
  22             *counter += by;
  23         }
  24     }
  25
  26     pub fn get(&self) -> usize {
  27         let counter = self.0.read().unwrap_or_else(|e| e.into_inner());
  28         *counter
  29     }
  30 }
  31
  32 // Now our counter is ready for action.
  33 pub fn main() {
  34     let counter = ConcurrentCounter::new(0);
  35
  36     // We clone the counter for the first thread, which increments it by 2 every 15ms.
  37     let counter1 = counter.clone();
  38     let handle1 = thread::spawn(move || {
  39         for _ in 0..10 {
  40             thread::sleep(Duration::from_millis(15));
  41             counter1.increment(2);
  42         }
  43     });
  44
  45     // The second thread increments the counter by 3 every 20ms.
  46     let counter2 = counter.clone();
  47     let handle2 = thread::spawn(move || {
  48         for _ in 0..10 {
  49             thread::sleep(Duration::from_millis(20));
  50             counter2.increment(3);
  51         }
  52     });
  53
  54     // Now we want to watch the threads working on the counter.
  55     for _ in 0..50 {
  56         thread::sleep(Duration::from_millis(5));
  57         println!("Current value: {}", counter.get());
  58     }
  59
  60     // Finally, wait for all the threads to finish to be sure we can catch the counter's final value.
  61     handle1.join().unwrap();
  62     handle2.join().unwrap();
  63     println!("Final value: {}", counter.get());
  64 }