use std::thread;

#[derive(Debug)]
struct Parent {
    id: i32,
    child: Option<Arc<Mutex<Child>>>,
}

impl Parent {
    pub fn get_value(&self) {
        println!("{}", self.id);
    }

    pub fn set_child(&mut self, child: Arc<Mutex<Child>>) {
        self.child = Some(child);
    }

    pub fn run(&self) {
        println!("run");
        if let Some(child_ref) = self.child.as_ref() {
            let child = child_ref.lock().unwrap(); // 使用lock来获取Mutex的互斥锁
            child.call_parent(self);
        }
    }
}

#[derive(Debug)]
struct Child {
    parent: Option<Arc<Mutex<Parent>>>,
}

impl Child {
    pub fn call_parent(&self, parent: &Parent) {
        parent.get_value();
    }
}

fn main() {
    println!("Hello, world!");
    let parent = Arc::new(Mutex::new(Parent { id: 123, child: None }));
    //如果注释掉这里会死锁，为什么？
    // {
        let child = Child { parent: Some(Arc::clone(&parent)) };
        let mut p = parent.lock().unwrap(); // 获取Parent的Mutex锁
        p.set_child(Arc::new(Mutex::new(child))); // 设置child
        p.run(); // 运行Parent的run方法
        //或者用这种方式来释放锁？测试也是可以的
        // drop(p); // 释放Parent的Mutex锁
    // }
    
    let parent_clone1=Arc::clone(&parent);
    let parent_clone2=Arc::clone(&parent);

    let thread1 = thread::spawn(move || {
        println!("{:?}", "thread1");
        let  p1 = parent_clone1.lock().unwrap(); // 获取Parent的Mutex锁
        println!("{:?}", p1);
    });
    let thread2 = thread::spawn(move || {
        println!("{:?}", "thread2");
        let  p2 = parent_clone2.lock().unwrap(); // 获取Parent的Mutex锁
        println!("{:?}", p2);
    });

    thread1.join().expect("thread1 Couldn't join on the associated thread");
    thread2.join().expect("thread2 Couldn't join on the associated thread");
    // println!("{:?}", child);
}```


问题在代码中，麻烦细看