执行了派生线程并释放了RwLock

之后，写访问尝试仍在阻塞主线程。

这是不正确的。添加基本​​调试输出以区分它们，则表明运行的唯一println是main中的那个。

不能保证在生成子线程之后哪个线程将首先执行。但是，主线程可能可以继续运行，因为它已经在运行。如果是这样，它将通过RwLock锁定rw并按住直到功能结束。但是，在函数结束之前，主线程将阻塞等待子线程的加入。子线程无法完成，因为它必须先获得写锁定。您已经创建了经典的死锁。

要解决此问题，请使用drop显式解锁锁，或添加范围以限制锁的寿命：

fn main() {
    let my = Arc::new(MySt {
        num1: 32,num2: 64,rw: RwLock::new(vec![1,2,3]),});
    let my2 = my.clone();
    let t = thread::spawn(move || {
        let mut rw = my2.rw.write().unwrap();
        rw[0] = 5;
        println!("thread a {},{},{}",my2.num1,my2.num2,rw[0],rw[1]);
    });
    //thread::sleep(time::Duration::from_millis(1000));
    let mut rw = my.rw.write().unwrap();
    rw[1] = 6;
    println!("thread b {},my.num1,my.num2,rw[1]);
    drop(rw);
    t.join().unwrap();
}

添加sleep可能会导致子线程首先执行。然后它将获取锁定并退出，从而允许主线程继续进行。

另请参阅：

• How to "unlock" an RwLock?

它不能正常工作的原因是，在子线程中的一个线程之前执行主线程中的锁定时，我没有释放锁定。我将其固定如下。

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

struct MySt {
    num1: i64,num2: i64,rw: RwLock<Vec<i64>>,}

fn main() {
    let my = Arc::new(MySt {
        num1: 32,});
    let my2 = my.clone();
    let t = thread::spawn(move || {
        let mut rw = my2.rw.write().unwrap();
        rw[0] = 5;
        println!("child thread {},rw[1]);
    });
    {
        let mut rw = my.rw.write().unwrap();
        rw[1] = 6;
        println!("main thread {},rw[1]);
    }
    t.join().unwrap();
}