rust 闭包与同步

rust 闭包

rust闭包中主要包括两个部分，闭包参数和闭包环境变量。
闭包函数和函数参数使用无太大区别。
闭包环境变量分为copy trait和非copy trait。
闭包分为move闭包和非move闭包。

copy trait变量，move闭包会将其单独移植进入闭包中，闭包内可修改，外部原始变量不受影响。
copy trait变量，非move闭包会将其原始变量移植入闭包，闭包内可修改，原始外部变量受影响。

非copy trait变量，move闭包会将其其单独移植进入闭包，闭包内可修改，外部原始变量失效。
非copy trait变量，move闭包会将其移入闭包，闭包内无法修改，外部原始变量不失效。

#[derive(Debug)]
pub struct Person {
    pub name: String,
    pub age: u32,
}

pub fn clone_struct_test_1() {
    let person_a = Person {
        name: String::from("wenbin"),
        age: 12,
    };

    let closure_fn = || person_a;

    let person_b = closure_fn();
    println!("{:?}", person_b);

    //    println!("{:?}",person_a);
}

pub fn clone_struct_test_1_1() {
    let mut person_a = Person {
        name: String::from("wenbin"),
        age: 12,
    };

    let closure_fn = || {
        let mut person_c = Person {
            name: person_a.name.clone(),
            age: person_a.age + 5,
        };
        //  this will report a error
        //        person_a.age = 17;
        person_c
    };

    let person_b = closure_fn();
    println!("{:?}", person_b);

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

pub fn clone_struct_test_1_2() {
    let mut person_a = Person {
        name: String::from("wenbin"),
        age: 12,
    };

    let closure_fn = move || {
        let mut person_c = Person {
            name: person_a.name.clone(),
            age: person_a.age + 5,
        };
        person_a.age = person_a.age + 12;
        (person_c, person_a)
    };

    let (person_b, person_a) = closure_fn();
    println!("{:?}", person_b);

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

pub fn clone_struct_test_2() {
    let mut person_a = Person {
        name: String::from("wenbin"),
        age: 12,
    };

    let closure_fn = |person_a| person_a;

    let mut person_b: &mut Person = closure_fn(&mut person_a);
    person_b.age = 13;
    println!("{:?}", person_b);

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

pub fn clone_struct_test_2_1() {
    let mut person_a = Person {
        name: String::from("wenbin"),
        age: 12,
    };

    let closure_fn = |person_a: &mut Person| {
        let mut person_c = Person {
            name: person_a.name.clone(),
            age: person_a.age + 23,
        };
        person_c
    };

    let mut person_b = closure_fn(&mut person_a);
    println!("{:?}", person_b);

    person_b.age = 13;
    println!("{:?}", person_b);
    println!("{:?}", person_a);
}

rust 同步

rust共享变量同步有mutex，RWLock，atomic。
mutex通常与arc结合，一起在多线程中使用。在多线程中使用需要将arc指针进行复制。
mutex的访问主要通过lock方法，当前线程阻塞时，会自动释放锁。

mutex自动通知，在rust中提供了根据event来通知其他线程的机制condvar。

// 代码中的Condvar就是条件变量，它提供了wait方法可以主动让当前线程等待，
// 同时提供了notify_one方法，让其他线程唤醒正在等待的线程。
// 这样就能完美实现顺序控制了。看起来好像条件变量把事都做完了，要Mutex干嘛呢？
// 为了防止多个线程同时执行条件变量的wait操作，
// 因为条件变量本身也是需要被保护的，这就是锁能做，而原子类型做不到的地方。
// 例子中可以看出，condvar和mutex想绑定，体现在wait方法：
// started = cvar.wait(started).unwrap();
pub fn sync_test_4(){
    let pair = Arc::new((Mutex::new(false), Condvar::new()));
    let pair2 = pair.clone();

    // 创建一个新线程
    thread::spawn(move|| {
        let &(ref lock, ref cvar) = &*pair2;
        println!("new thread start");
        let mut started = lock.lock().unwrap();
        *started = true;
        thread::sleep_ms(10000);
        cvar.notify_one();
        println!("notify main thread");
    });

    // 等待新线程先运行
    let &(ref lock, ref cvar) = &*pair;
    let mut started = lock.lock().unwrap();
    while !*started {
        println!("before wait");
        started = cvar.wait(started).unwrap();
        println!("after wait");
    }
}