请对std::sync::{Arc, RwLock, Weak};三种类型分别举一些例子

1. Arc（原子引用计数类型）示例：

use std::sync::Arc;
use std::thread;

fn main() {
    let data = vec![1, 2, 3];
    let shared_data = Arc::new(data);

    let mut threads = vec![];

    for i in 0..3 {
        let data_ref = shared_data.clone();

        let handle = thread::spawn(move || {
            let local_data = &data_ref[..];
            println!("Thread {}: {:?}", i, local_data);
        });

        threads.push(handle);
    }

    for handle in threads {
        handle.join().unwrap();
    }
}

在这个例子中，我们创建了一个包含数字的 `Vec`，并将其包装在 `Arc` 中。然后，我们创建了三个线程，每个线程都从 `Arc` 中获取数据，并打印出来。由于 `Arc` 允许多个线程同时访问同一数据，因此我们可以安全地共享数据而不必担心竞争条件。

2. RwLock（读写锁类型）示例：

use std::sync::RwLock;

fn main() {
    let data = RwLock::new(vec![1, 2, 3]);

    {
        let mut write_guard = data.write().unwrap();
        write_guard.push(4);
        write_guard.push(5);
    }

    {
        let read_guard = data.read().unwrap();
        println!("Data: {:?}", *read_guard);
    }
}

在这个例子中，我们创建了一个包含数字的 `Vec`，并将其包装在 `RwLock` 中。然后，我们获取一个写锁，并向数据中添加两个元素。之后，我们获取一个读锁，并打印出数据。由于 `RwLock` 允许多个线程同时读取数据，但只允许一个线程写入数据，因此我们可以安全地更新数据而不必担心竞争条件。

3. Weak（弱引用类型）示例：

use std::sync::{Arc, Weak};
use std::cell::RefCell;

#[derive(Debug)]
struct Node {
    value: i32,
    parent: RefCell<Weak<Node>>,
    children: RefCell<Vec<Arc<Node>>>,
}

fn main() {
    let root = Arc::new(Node {
        value: 0,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    let child1 = Arc::new(Node {
        value: 1,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    let child2 = Arc::new(Node {
        value: 2,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    child1.parent.borrow_mut().replace(Arc::downgrade(&root));
    child2.parent.borrow_mut().replace(Arc::downgrade(&root));

    root.children.borrow_mut().push(child1.clone());
    root.children.borrow_mut().push(child2.clone());

    println!("Root: {:?}", root);
    println!("Child1: {:?}", child1);
    println!("Child2: {:?}", child2);
}

在这个例子中，我们创建了一个树形结构，其中每个节点都有一个值、一个父节点和多个子节点。我们使用 `Arc` 来保持对节点的所有权，并使用 `Weak` 来表示对父节点的弱引用，以避免循环引用。我们还使用 `RefCell` 来允许在节点之间进行互相引用，即父节点引用其子节点，而子节点引用其父节点。这个例子展示了如何使用 `Arc` 和 `Weak` 来创建一个安全的、可循环引用的数据结构。