the rust book

use std::mem::size_of_val;

let c1 = 'a'; // 1字节编码 
assert_eq!(size_of_val(&c1),4); 

let c2 = '中'; // 3字节编码
assert_eq!(size_of_val(&c2),4); 

fn first_word(s:&str) -> &str{
    //..
}
fn main(){
    let source = "hello".into_string();
    let a =first_word(&source[..]);
    let b =first_word("hello world");
    let c =first_word(&source);
    let d = first_word(source.as_str());
}

struct Point(f32,f32,f32) ;

fn main(){
    let p = Point(0.0, 1.0, 2.0);
    println!("{:?}", p.0 );
}

struct AlwaysEqual;

fn main() {
    let subject = AlwaysEqual; 

}

enum Option<T> {
    Some(T),
    None,
}

fn use_match(op: Option<i32>) -> i32 {
    match op {
        Some(val) => val  ,
        None => -1 ,
    }
}

let val = Some(32);

if let Some(v) = val { // Some(v) 
    println!("{}", v);
} else { // None
    println!("nothing");
}

fn change_str(s: &mut String) {
    s.push_str(s);
}

fn main() {
    let mut s = String::from("mutable");
    change_str(&mut s);
}

  fn main() {
      let mut source = String::from("hello");
      let mref = &mut source;
//ERROR: let imref = &source; // 位于mref的使用范围! 
      print!("{:?}", mref);
  }

fn main() {
    let mut s = String::from("hello");
    {
        let r1 = &mut s;
    } // r1 goes out of scope here, so we can make a new reference with no problems.
    let r2 = &mut s;
}

trait Foo {
    fn method(&self) -> String;
}

impl Foo for u8 {
    fn method(&self) -> String { format!("u8: {}", *self) }
}

impl Foo for String {
    fn method(&self) -> String { format!("string: {}", *self) }
}

// 通过泛型实现以下函数
fn static_dispatch<T:Foo>(a:T) {
    a.method();
}

// 通过特征对象实现以下函数
fn dynamic_dispatch(a: &dyn Foo){

    a.method();
}

fn main() {
    let x = 5u8;
    let y = "Hello".to_string();

    static_dispatch(x);
    dynamic_dispatch(&y);

    println!("Success!")
}

trait GetInt {
    fn get_int(&self) -> u64;
}

struct WhyNotU8 {// vtable stored at section L__unnamed_1
    x: u8
}

struct ActualU64 {// vtable stored at section L__unnamed_2
    x: u64
}

impl GetInt for WhyNotU8 {
    fn get_int(&self) -> u64 {
        self.x as u64
    } 
} 

impl GetInt for ActualU64 {
    fn get_int(&self) -> u64 {
        self.x
    }
}


// `&dyn`表明我们要使用动态分发,而不是单态化. 因此在生成的汇编中只有一个`retrieve_int`函数.
// 若此处使用泛型,那么在生成的汇编中,对每个实现GetInt的类型都有一个相应的`retrieve_int`函数 
pub fn retrieve_int(u: &dyn GetInt) { // <<<<<<<<<<<<<<<<!!!!!!!!!!!!!!!!

        // 在汇编中, 我们仅仅调用传入rsi中的地址(对应get_int的地址)
    //并期望在调用即将发生前, rsi被正确设置
    let x = u.get_int();
}

pub fn do_call() {

  // 即便 `WhyNotU8` 和 `ActualU64` 对应的vtable表项中有 `core::ptr::real_drop_in_place`的函数指针, 这个函数也从来不被实际调用. 
    let a = WhyNotU8 { x: 0 };
    let b = ActualU64 { x: 0 };

    retrieve_int(&a);
    retrieve_int(&b);
}

core::ptr::drop_in_place<example::WhyNotU8>: 
  retq 

core::ptr::drop_in_place<example::ActualU64>: 
  retq 

<example::WhyNotU8 as example::GetInt>::get_int: 
  movzbl (%rdi), %eax  ;; 将get_int的第1参数(引用/指针)所指向的数据 放入eax作为返回值 
  retq 

<example::ActualU64 as example::GetInt>::get_int: 
  movq (%rdi), %rax  ;; 将get_int的第1参数(引用/指针)所指向的数据 放入rax作为返回值 
  retq 

example::retrieve_int:     ;; fn retrieve_int(u: &dyn GetInt) -> ()
  pushq %rax      ;; 为了满足规定:call之前stack是按16字节对齐的(上一次call压入的8字节返回地址破坏了这点)
  callq *24(%rsi)  ;; rsi 为每个Table表项的起始地址
                           ;; rsi + 24处存放着指向 函数<example::??? as example::GetInt>::get_int 的指针 
                           ;; call *24(%rsi) = call *(rsi+24) ==> 调用对应的get_int()函数      
  popq %rax  
  retq

example::do_call: 
  subq $24, %rsp        ;;在stack上分配 24 字节 
  movb $0, 15(%rsp)     ;; let b = ActualU64 { x: 0 };
  movq $0, 16(%rsp)     ;; let a = WhyNotU8 { x: 0 };
  leaq 15(%rsp), %rdi   ;; rdi <- rsp + 15  将对b的引用作为第一参数
  leaq .L__unnamed_1(%rip), %rsi                ;; rsi <- 表项.L__unnamed_1的起始地址
  callq *example::retrieve_int@GOTPCREL(%rip)   ;; 调用 retrieve_int()
  leaq 16(%rsp), %rdi           ;; rdi <- rsp + 16  将对a的引用作为第一参数
  leaq .L__unnamed_2(%rip), %rsi                ;; rsi <- 表项.L__unnamed_2的起始地址
  callq *example::retrieve_int@GOTPCREL(%rip)           ;;调用 retrieve_int()
  addq $24, %rsp          ;; 归还 stack 上空间
  retq 


;;  vtable: 
.L__unnamed_1: ;; 此处地址 + 24 字节 == 指向get_int()的指针 
  .quad core::ptr::drop_in_place<example::WhyNotU8> ;; 8 字节 
  .asciz "\001\000\000\000\000\000\000\000\001\000\000\000\000\000\000" ;; 16 = 15 + 1 字节
  .quad <example::WhyNotU8 as example::GetInt>::get_int ;; 8 字节, 指向相应的get_int()的指针 


.L__unnamed_2: ;; 此处地址 + 24 字节 == 指向get_int()的指针 
  .quad core::ptr::drop_in_place<example::ActualU64>  ;; 8 字节  
  .asciz "\b\000\000\000\000\000\000\000\b\000\000\000\000\000\000" ;; 16 = 15 + 1 字节
  .quad <example::ActualU64 as example::GetInt>::get_int  ;; 8 字节,  指向相应的get_int()的指针 

fn func<T: Sized> (t: T) {
    /// ... 
}

/// std::mem
pub const fn size_of_val<T: ?Sized>(val: &T) -> usize {
    // SAFETY: `val` is a reference, so it's a valid raw pointer
    unsafe { intrinsics::size_of_val(val) }
}

mod plant_structures{

    pub mod roots{ // 根

    }
    pub mod stems{ // 茎

    }
    pub mod leaves{ // 叶

    }
}

mod plant_structures{

    pub mod roots{

        pub mod products{

            pub(in crate::plant_structures::roots) struct Cytokinin { 
                // 细胞分裂素 
            }
        }
    }
    // ERROR: 
    // use roots::products::Cytokinin ;
}
// ERROR:
// use plant_structures::roots::products::Cytokinin;

mod foo; 

// main.rs:
pub mod plant_structures; 

fern_sim/
├── Cargo.toml
└── src/
    ├── main.rs
    ├── spores.rs
    └── plant_structures/
        ├── mod.rs
        ├── leaves.rs
        ├── roots.rs
        └── stems.rs

// mod.rs : 
pub mod roots;
pub mod stems;
pub mod leaves;

//  plant_structures.rs
pub mod roots;
pub mod stems;
pub mod leaves;

fern_sim/
  ├── Cargo.toml
  └── src/
      ├── main.rs
      ├── spores.rs
      ├── plant_structures.rs
      └── plant_structures/
          ├── leaves.rs
          ├── roots.rs
          └── stems.rs

use std::mem;

use std::io::prelude::* ;

use std::fs::{self, File};

use std::fs;
use std::fs::File;

use std::io::Result as IOResult ;

//in submodule:
use super::Foo;

use super::* ;

use ::image::Pixels;  // image为引入的crate 

/// lib.rs in crate std

extern crate core; /// <<====
//...
pub use core::clone;
pub use core::cmp;
pub use core::convert;
pub use core::default;
pub use core::future;
pub use core::hash;
pub use core::hint;
pub use core::i128;
pub use core::i16;
pub use core::i32;
pub use core::i64;
pub use core::i8;
pub use core::intrinsics;
pub use core::isize;
pub use core::iter;
// ......
pub use core::mem; /// <<====
// ......

/// lib.rs in crate std
extern crate core;
// ......
pub use core::mem;

pub struct Foo {
    pub first : i32,
    pub second: u32, 
}

// main.rs
struct Fern {
    size : f64,
    growth_rate:f64,
}
impl Fern {
    fn grow(&mut self) {
        self.size *= 1.0 + self.growth_rate ;
    }
}
fn run_simulation(fern:&mut Fern,days:usize) {
    for _ in 1..=days {
        fern.grow();
    }
}
/// =================================
fn main(){
    let mut fern = Fern{
        size: 1.0,
        growth_rate: 0.001,
    };
    run_simulation(&mut fern,1000);
    println!("final fern size: {}",fern.size);
}

/// lib.rs
pub struct Fern {   // << 
    pub size : f64,  // <<
    pub growth_rate:f64, // <<
}
impl Fern {
    fn grow(&mut self) {
        self.size *= 1.0 + self.growth_rate ;
    }
}
pub fn run_simulation(fern:&mut Fern,days:usize) { // <<
    for _ in 1..=days {
        fern.grow();
    }
}

/// src/bin/efern.rs 
use 此crate::{Fern,run_simulation};

fn main(){
     let mut fern = Fern{
         size: 1.0,
         growth_rate: 0.001,
     };
     run_simulation(&mut fern,1000);
     println!("final fern size: {}",fern.size);
 }

cargo build

cargo run --bin efern # main()所在文件名 

.
├── Cargo.lock
├── Cargo.toml
├── src
│   ├── bin
│   │   ├── another_exe
│   │   │   ├── main.rs
│   │   │   └── sth.rs
│   │   └── fern_sim.rs
│   └── lib.rs

......

let mut b = Box::new(123_i32) ;
let raw_ptr  = Box::leak(b);
//println!("{}", *b);  b 已经被移走 !

let newb : Box<i32> = unsafe{Box::from_raw(raw_ptr) }; // 重新管理的泄漏的指针 
std::mem::drop(newb); // 将newb所有权移动到mem::drop函数参数上,离开函数后自动调用 box.drop 
// 不同于 newb.drop(), 这个是离开作用域后真正负责释放内存的函数 

fn get_str() -> &'static str {
    let mut s = String::new();
    s.push_str("hello");

    Box::leak(s.into_boxed_str()) 
}

#[derive(Debug)]
struct Inner{
    data:u32 ,
}

impl Clone for Inner {
    fn clone(&self) -> Self {
        eprintln!("===>[copy Inner]"); // !!!只要发生拷贝就会有输出
        Self{
            data: self.data,
        }
    }
}
impl Copy for Inner {}

use std::cell::*;
let c = Cell::new(Inner{data: 233});

let v1 = c.get();
let v2 = c.get(); // c中的数据没有被move

let inner = Inner{ data : 3333} ;
c.set(inner); 

/// 无任何输出!! 

use std::cell::RefCell;
   use std::rc::Rc;

   let  s = Rc::new(RefCell::new(String::from("hello")));
   s.borrow_mut().push_str("hello");

   println!("{:?}",s);

&mut Vec<T> ==> &mut [T]

&mut [T] ==> &Cell<[T]>

&Cell<[T]> ==> &[Cell<T>] 

let mut v = vec![1,2,4,5];
////////////////////////////////////

let refv = &mut v;

let vv: &[Cell<i32>] = Cell::from_mut(&mut refv[..]) .as_slice_of_cells();
let mut i = 0 ; 
for ele in vv.iter() .filter(|&n| n.get() %2 == 0) {
    vv[i].set( ele.get() );
    i = i+1;
}
refv.truncate(i);// 只保留前i个元素
println!("{:?}" ,  v); // [2,4] 

let mut v = vec![1,2,4,5];
let refv = &mut v;
let mut i = 0 ;
for ele in refv.iter() .filter(|&n| *n %2 == 0) { // << ERROR!!
    refv[i] = *ele; /// << ERROR!! &mut 
    i = i+1;
}

let handle = thread::spawn(||{
    thread::park(); // 阻塞线程
    println!("hello!");
});

println!("world");

handle.thread() // 获得线程对象
  .unpark(); // 恢复线程的执行

while !满足条件 {
    thread::park();
}

let handle =  thread::spawn(|| {
    for i in 0..10 {
        println!("spawned thread: {}",i);
        thread::sleep(Duration::from_millis(1) ); 
    }
});

handle.join().unwrap();// 调用了该方法的线程会(阻塞)等待handle所代表的线程完成 

for i in 0..5 {
    println!("main thread: {}", i);
    thread::sleep(Duration::from_millis(1));
}

spawned thread: 0
spawned thread: 1
spawned thread: 2
spawned thread: 3
spawned thread: 4
spawned thread: 5
spawned thread: 6
spawned thread: 7
spawned thread: 8
spawned thread: 9
main thread: 0
main thread: 1
main thread: 2
main thread: 3
main thread: 4

data.clone() // -> 通过Arc克隆指针, 获得一部分所有权
    .lock() // -> 阻塞式尝试加锁 Result
    .unwrap() // -> MutexGraud 指针, 可修改数据

#[test]
fn thread_barrier() {
    use std::sync::Arc;
    use std::sync::Barrier;
    use std::thread;

    let mut handles = Vec::with_capacity(6);

    // 创建 barrier:
    // 1. Arc + Barrier
    // 2. 指定使用此barrier的线程数
    let barrier = Arc::new(Barrier::new(6));

    for _ in 0..6 {
        let b = barrier.clone();
        handles.push(thread::spawn(move || {
            println!("before barrier");
            b.wait();
            println!("after barrier");
        }));
    }
    for h in handles {
        h.join().unwrap();
    }
}

    });
}



// 通过共享内存来进行线程的通信

#[test]
fn single_producer_single_consumer() {
    use std::sync::mpsc;
    use std::thread;

    let (s, r) = mpsc::channel();

    thread::spawn(move || {
        s.send(233).unwrap();
    });
    // recv() 会阻塞线程. 直到受到信息/通道关闭
    // (因此这里main线程不用join子线程 )
    eprintln!("main receive: {}", r.recv().unwrap());
}

// 用不阻塞的try_recv():
// 返回值有三类
// main try receive: Err(Empty) 未收到消息
// main try receive: Ok("233")
// main try receive: Err(Disconnected) 管道已断开
#[test]
fn single_producer_single_consumer_nonblock() {
    use std::sync::mpsc;
    use std::thread;

    let (p, c) = mpsc::channel();

    let child = thread::spawn(move || {
        p.send("233").unwrap();
    });

    // child.join().unwrap();

    loop {
        let res = c.try_recv();
        eprintln!("main try receive: {:?}", res);
        if res == Err(mpsc::TryRecvError::Disconnected) {
            break;
        }
    }
}

// send 会根据是否实现Copy来选择拷贝被发送的数据,还是move被发送的数据 (和clone无关)
#[test]
fn send_move_or_copy() {
    use std::sync::mpsc;
    use std::thread;

    let (tx, rx) = mpsc::channel();

    let child = thread::spawn(move || {
        let s = String::from("hello world");
        tx.send(s).expect("send error");
        // s已经被move:    eprintln!("{}", s);
    });

    let r = rx.recv().unwrap();
    println!("Got : {}", r);
}

// 可用for res in rx { }
// 从 receive端连续接收数据, 无需手动 .recv()
// 当发送者被drop/通道关闭后 for 循环终止
#[test]
fn receive_from_channel_continuously() {
    use std::sync::mpsc;
    use std::thread;
    use std::time::Duration;

    let (tx, rx) = mpsc::channel();
    thread::spawn(move || {
        let vals = vec![
            String::from("how"),
            String::from("are"),
            String::from("you"),
            String::from(" ?"),
        ];
        for val in vals {
            tx.send(val).unwrap();
            thread::sleep(Duration::from_secs(1));
        }
    });

    for recv in rx {
        println!("got: {}", recv);
    }
}

// 多个发送者,
// 仍用channel() 创建通道
// 不同之处在于要clone()出多个发送者
// 当所有发送者都被drop后, recv才会接收到错误信息, 从而跳出循环
// 下面的代码会多创建出一个sender, 因此 下面的for不会自然停止.
// 除非 手动将tx drop掉

#[test]
fn multiple_producers() {
    use std::sync::mpsc;
    use std::thread;

    let (tx, rx) = mpsc::channel();

    let mut handles = Vec::with_capacity(2);
    for i in 0..2 {
        // 创建线程前先clone出发送端.
        let sender = tx.clone();

        let child = thread::spawn(move || {
            sender
                .send(format!("this msg is from thread {}", i))
                .unwrap();
        });
        handles.push(child);
    }

    drop(tx);
    for res in rx {
        eprintln!("got: {}", res);
    }
}

// channel() 是异步发送的管道. 无论对段是否接收到消息, 发送端会立刻完成send()方法.
// sync_channel() 创建出的是同步发送的通道, send()直到接收端成功接收到信息后才会返回.
#[test]
fn sync_channel_without_buffer() {
    use std::sync::mpsc;
    use std::thread;
    use std::time::Duration;

    let (tx, rx) = mpsc::sync_channel(0);

    let handle = thread::spawn(move || {
        tx.send("fuck").unwrap(); // 阻塞 !
        eprintln!("完成发送!")
    });

    thread::sleep(Duration::from_secs(5));
    eprintln!("got: {}", rx.recv().unwrap());

    handle.join().unwrap();
}

// sync_channel(N) 接收一个参数作为缓冲区的大小, 当缓冲区满时, send()会发生阻塞.否则send() 将立刻返回.

#[test]
fn sync_channel_with_buffer() {
    use std::sync::mpsc;
    use std::thread;
    use std::time::Duration;

    let (tx, rx) = mpsc::sync_channel(1);

    let handle = thread::spawn(move || {
        tx.send("fuck").unwrap(); // 被成功接收
        eprintln!("Send the first message.");
        tx.send("you").unwrap(); // 被存入通道的buffer
        eprintln!("Send the second message.");
        tx.send(" !").unwrap(); // buffer已满且对端未接收, 会阻塞在此处 !
        eprintln!("Send the third message.");
    });

    eprintln!("got :{}", rx.recv().unwrap());
    handle.join().unwrap();
}
// 所有发送者被drop或者所有接收者被drop后，通道会自动关闭 !!

// 读写mutex之前都要先lock()
//Arc + mutex 是多线程中的 Rc<RefCell> , 提供了内部字段的可变性
#[test]
fn useing_mutex_as_smart_pointer() {
    use std::sync::{Arc, Mutex};
    use std::thread;
    // 全局计数器
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let cnt = counter.clone();
        let child = thread::spawn(move || {
            let mut guard = cnt.lock().unwrap();
            // mut 的指针. MutexGuard 实现了 Deref 和 DerefMut, 用来返回Mutex<T>对象的&T和&mut T. 
            *guard += 1; 
        });
        handles.push(child);
    }

    for h in handles {
        h.join().unwrap();
    }
    eprintln!("counter: {}", *counter.lock().unwrap());
}

// 锁mutex vs  消息传递(channel)
// 1.读写前都要获得锁. lock()在拿不到锁时会发生阻塞!!
// 2.需要及时释放锁. (否则可能死锁)
// 3.比起channel会少了很多额外的内存拷贝(但使用起来麻烦)

// RwLock读写锁
// 支持并发读.
// 开销比mutex更大, 仅仅在对读到的数据的操作开销 >> 加/解 读写锁 的开销 时才考虑使用.
// 否则 用mutex完成读后解锁效率会更高.

#[test]
fn read_and_write_lock() {
    use std::sync::Arc;
    use std::sync::RwLock;

    let lock = Arc::new(RwLock::new(233));

    let lock_child = lock.clone();
    let child = thread::spawn(move || {
        let res = lock_child.read().unwrap();
        eprintln!("child read {}", *res);
        drop(res); // !!!! 释放读锁, 否则下面的write()会阻塞.

        let mut ptr = lock_child.write().unwrap();
        *ptr += 1;
        drop(ptr); // 释放写锁

        let res2 = lock_child.read().unwrap();
        eprintln!("child after writing {}", *res2);
    });

    child.join().unwrap();

    eprintln!("main {}", *lock.read().unwrap());
}

// 用条件变量来控制mutex何时尝试加锁, 避免忙等待(一直尝试获得锁)
// Arc + mutex
// Arc + Condvar
#[test] // 交替打印
fn alternate_printing() { 
    use std::sync::{Arc, Condvar, Mutex};
    use std::thread;

    #[derive(Clone, Debug)]
    enum Next {
        Child,
        Main,
    }

    let next = Arc::new(Mutex::new(Next::Main));
    let cond = Arc::new(Condvar::new());

    let next2 = next.clone();
    let cond2 = cond.clone();

    let handle = thread::spawn(move || {
        let mut lock = next2.lock().unwrap();
        let mut next_flag = (*lock).clone();
        drop(lock);

        for i in 1..=3 {
            while let Next::Main = next_flag {
                next_flag = (*cond2.wait(next2.lock().unwrap())
                             .unwrap()).clone();
            } // next_flag 为 Next::Child 时跳出 while-loop

            eprintln!("child:\t{}", i);

            next_flag= Next::Main;
            *next2.lock().unwrap() = next_flag.clone();// 下一个进行打印的是main线程
        }
    });

    for i in 1..=3 {
        eprintln!("main:\t{}", i);

        let mut next_flag = next.lock().unwrap();
        *next_flag = Next::Child; // 下一个进行打印的是child线程
        drop(next_flag);

        cond.notify_one();
        thread::sleep(Duration::from_secs(1));
        //睡一秒, 给child线程提供上锁的机会. 
    }
    handle.join().unwrap();
}


// tokio中的信号量
use std::sync::Arc;
use tokio::sync::Semaphore; 

// 创建 5 个任务
// 前3个被立即创建. 信号量用完,且没有释放.
// 等待5秒后, 剩下两个任务才被创建出来. 

#[tokio::main]
async fn main() {
    let semaphore = Arc::new(Semaphore::new(3));// 信号量的容量为3

    let mut join_handles = Vec::new();

    for i in 0..5 {
        let permit  = semaphore.clone().acquire_owned().await.unwrap();// 申请占用一个信号量
        // 当信号量的容量用光后 会阻塞. 

        let handle = tokio::spawn(async move {
                //do something
                eprintln!("thread {}",i);
                thread::sleep(Duration::from_secs(5));
                drop(permit);// 释放信号量 
        });
        join_handles.push(handle);
    }

    for h in join_handles {
        h.await.unwrap();
    }
}

use std::ops::Deref;

pub struct Rc<T> {

    inner: *mut Inner<T>,
}

struct Inner<T> {
    count: usize,
    value: T,
}

impl<T> Rc<T> {
    pub fn new(val : T) -> Self{
        Self{
            inner: Box::into_raw(Box::new(
                Inner{
                    count: 0,
                    value: val,
                }
            ))
        }
    }
}

impl<T> Clone for Rc<T> {

    fn clone(&self) -> Self {
        unsafe{&mut *self.inner}.count += 1;
        Self {
            inner: self.inner
        }
    }

}


impl<T> Drop for Rc<T> {
    fn drop(&mut self) {
        let count = &mut unsafe{&mut *self.inner }.count;
        if *count == 1 {
            let _ = unsafe {Box::from_raw(self.inner) } ;
        }else {
            *count -=1;
        }
    }
}


impl<T> Deref for Rc<T> {

    type Target = T;

    fn deref(&self) -> &Self::Target {
        &mut unsafe{&mut *self.inner}.value
    }
}

fn main() {
    let x = Rc::new(1);
    let y = x .clone();

    std::thread::spawn(move || {
        let aa  = y; // ERROR!!!
    });/// y在此处drop()

    /// x在此处drop()
}

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

#[test]
fn condvar_mutex() {
    let lock = Arc::new((Mutex::new(false), Condvar::new()));

    let lock2 = lock.clone();

    thread::spawn(move || {
        let (ref lk, ref cond) = *lock2;
        let mut pdata= lk.lock().expect("lock"); // 子线程取得锁
        eprintln!("start changing!!!");
        *pdata = true;
        cond.notify_one(); // 修改后通知在同一条件变量上等待的其它一个线程
    });


    let (ref lk, ref cond) = *lock;
    // Mutex ===lock()===> MutexGuard:被锁保护的值
    //                     [用lock()获得锁后的产物,可读可写]
    let mut pdata = lk.lock().unwrap();

    // wait释放锁并陷入阻塞
    // wait(MutexGuard) ==> 解锁并阻塞
    while *pdata != true {
        // 用循环验证值是否以及满足条件?
        pdata = cond.wait(pdata).unwrap(); //收到通知后, 加锁,并返回当前值
        // 必须比较新获得的值是否满足条件, 不满足则再次用wait释放锁并进入阻塞.
    }

    eprintln!("finished {:?}", started);
}

use std::sync::Once;
static mut VAL: usize = 0;
static INIT: Once = Once::new();

#[test]
fn call_once_func() {
    use std::thread;

    let child1 = thread::spawn(|| {
        INIT.call_once(|| unsafe {
            VAL = 1;
        })
    });

    let child2 = thread::spawn(|| {
        INIT.call_once(|| unsafe {
            VAL = 2;
        })
    });

    child1.join().unwrap();
    child2.join().unwrap();

    eprintln!("VAL = {}", unsafe { VAL });
}

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

let mut handles = Vec::with_capacity(5);
let barrier = Arc::new(Barrier::new(5)); // <<===!!

for i in 0..5 {
    let b = barrier.clone();
    handles.push(thread::spawn(move ||{
        println!("before barrier: thread<{i}> is ready.");
        b.wait(); // <<=====!!
        println!("after barrier: thread<{i}> go!")
    }))
}

for h in handles {
    h.join().unwrap();
}

before barrier: thread<0> is ready.
before barrier: thread<1> is ready.
before barrier: thread<2> is ready.
before barrier: thread<4> is ready.
before barrier: thread<3> is ready.
after barrier: thread<3> go!
after barrier: thread<1> go!
after barrier: thread<2> go!
after barrier: thread<0> go!
after barrier: thread<4> go!

let live = Arc::new(AtomicBool::new(false));

// In a background thread we'll eventually set the value
let bg_work = {
    let live = live.clone();
    thread::spawn(move || {
        // Do some work, then make the value live
        do_some_work();
        live.store(true, Ordering::Release);
    })
};

// Back on our current thread, we wait for the value to be set
while !live.load(Ordering::Acquire) {
    // The spin loop is a hint to the CPU that we're waiting, but probably
    // not for very long
    hint::spin_loop();
}