『並行プログラミング入門』読書メモ+Rustハンズオン

fn main() {
    let f1 = x_up(2);
    let f2 = double_up_with_dummy_arg(2);
    
    println!("{}",double_up(2));    // 4
    println!("{}",f1(0));           // 0
    println!("{}",f2(0));           // 4
}

fn double_up (n:u16) -> u16 {
    n * 2 
}

fn x_up (x:u16) -> Box::<dyn Fn(u16)->u16> {
    Box::new(move|y| x * y)
}

fn double_up_with_dummy_arg (x:u16) -> Box::<dyn Fn(u16)->u16> {
    Box::new(move|_| x * 2)
}

fn main() {
    let x = 1;
    {
        let y = 2;
        let sum = add(&x,&y);
        let sum2 = add2(&x,&y);
        println!("{sum}");  // 3
        println!("{sum2}"); // 3
    }
    
    fn add<'a>(x:&'a i32, y:&'a i32)->i32{
        x+y
    }

    fn add2(x:&i32, y:&i32)->i32{
        x+y
    }
}

use std::sync::atomic::{AtomicUsize, Ordering};

fn main() {
    let orders:Vec<Ordering> = vec![Ordering::AcqRel,Ordering::Acquire,Ordering::Relaxed,Ordering::Release,Ordering::SeqCst];
    for order in orders {
        let u_atom = AtomicUsize::new(0);
        let lap = std::time::Instant::now();
        for _ in 0..1_000_000_000{
            u_atom.fetch_add(1, order);
        }
    println!("{:?}\t{:?}",order,lap.elapsed());
    }
}

AcqRel  951.2733ms
Acquire 979.2315ms
Relaxed 930.7686ms
Release 944.774ms
SeqCst  943.9852ms

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

const MAX_NUM:usize =5;
fn main() {
    let mut v = Vec::new();

    let barrier = Arc::new(Barrier::new(MAX_NUM));

    for i in 0..MAX_NUM {
        let b = barrier.clone();
        let th = thread::spawn(move || {
            println!("before wait {i}");
            b.wait();
            println!("after wait {i}");
        });
        v.push(th);
    }

    for th in v {
        th.join().unwrap();
    }
}

before wait 0
before wait 3
before wait 2
before wait 1
before wait 4
after wait 0
after wait 4
after wait 1
after wait 2
after wait 3
`

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

/// 以下のコードはデッドロックとなる場合、ならない場合を示しています
fn main() {
    let val: Arc<RwLock<bool>> = Arc::new(RwLock::new(true));

    let t thread::JoinHandle<()> = thread::spawn(move||{
-        let flag: RwLockReadGuard<bool> = val.read().unwrap();
-        if *flag {
+        let flag: bool = *val.read().unwrap();
+        if flag {
            *val.write().unwrap() = false;
            println!("flag is true");
        }
    });

    t.join().unwrap()
}

use std::{sync::{Arc, Mutex, MutexGuard, TryLockError}, thread};

/// `lock()`じゃなくて`try_lock()`を使って書けば冗長だけどハマりずらくなるかもしれない
/// あと、line:2で`try_lock()`使ってるならmatch書いた方が丁寧なのですがdiff見やすくするために省略


fn main(){
    let lock0: Arc<Mutex<i32>> = Arc::new(Mutex::new(0));

    let a: MutexGuard<i32> = lock0.try_lock().unwrap();
    println!("{}",a);
    
-    let b: MutexGuard<i32> = lock0.lock().unwrap();
-    println!("{}",b);
+    let b: Result<MutexGuard<i32>, TryLockError<MutexGuard<i32>>> = lock0.try_lock();
+    match b {
+        Ok(ok)  => println!("{}",ok),
+        Err(err) => println!("{}",err),
+    }
}

use std::{sync::{Arc, Condvar, Mutex, RwLock, RwLockReadGuard}, thread};

fn main() {
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair_clone = Arc::clone(&pair);

    // スレッド1
    let t1 = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        let mut started = lock.lock().unwrap();
        while !*started {
            println!("Thread 1 waiting...");
            started = cvar.wait(started).unwrap();
        }
        println!("Thread 1 awakened!");
    });

    // スレッド2
    let pair_clone = Arc::clone(&pair);
    let t2 = thread::spawn(move || {
        let (lock, cvar) = &*pair_clone;
        
        let mut started = lock.lock().unwrap();
        *started = true;
        println!("Thread 2 notifying...");
-        cvar.notify_one(); // 通知を送るが、ここで疑似覚醒が発生する可能性がある
+      //cvar.notify_one(); // 通知を送るが、ここで疑似覚醒が発生する可能性がある
        println!("Thread 2 notified...");
    });

    t2.join().unwrap();
    println!("t2 end");
    t1.join().unwrap();    
}