싱글스레드 환경

싱글스레드 환경에서는 Rc<T>와 RefCell<T>의 조합이 주로 사용됩니다.
Rc는 다중 소유권(참조 카운팅), RefCell은 런타임에 가변 접근을 제공합니다.

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

fn main() {
    let data = Rc::new(RefCell::new(vec![1, 2, 3]));
    let data_clone = Rc::clone(&data);

    data.borrow_mut().push(4);
    data_clone.borrow_mut().push(5);
    println!("데이터: {:?}", data.borrow());
}

순환 참조가 발생할 수 있는 구조에서는 Weak<T>를 사용해야 합니다.

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Node {
    next: Option<Rc<RefCell<Node>>>,
    prev: Option<Weak<RefCell<Node>>>,
    value: i32,
}

impl Node {
    fn new(value: i32) -> Rc<RefCell<Self>> {
        Rc::new(RefCell::new(Node {
            next: None,
            prev: None,
            value,
        }))
    }
}

fn main() {
    let first = Node::new(1);
    let second = Node::new(2);

    {
        let mut first_ref = first.borrow_mut();
        let mut second_ref = second.borrow_mut();

        first_ref.next = Some(Rc::clone(&second));
        second_ref.prev = Some(Rc::downgrade(&first));
    }
}

멀티스레드 환경

멀티스레드 환경에서는 Arc<T>와 Mutex<T>의 조합이 필요합니다.
Arc는 원자적 참조 카운팅으로 스레드 안전한 다중 소유권을, Mutex는 락 기반의 가변 접근을 제공합니다.

use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

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

    for i in 0..3 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            thread::sleep(Duration::from_millis(10 * i as u64));
            let mut data = data_clone.lock().unwrap();
            data.push(i + 4);
            println!("스레드 {}: {:?}", i, *data);
        });
        handles.push(handle);
    }

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

    println!("최종 데이터: {:?}", *data.lock().unwrap());
}

Mutex 락은 가능한 짧게 유지하고, 데드락을 피하기 위해 락 획득 순서를 일관되게 유지해야 합니다.