[Rust] Rc와 RefCell 같이 활용하여 가변의 복수 소유자 만들기

Rust에서는 데이터의 가변성과 소유권 시스템을 통해 메모리 안전성을 보장합니다. 그러나 가변 데이터를 여러 소유자가 공유해야 하는 상황에서는 Rc<T>와 RefCell<T>의 조합이 강력한 해결책이 됩니다. 이 글에서는 Rc<T>와 RefCell<T>를 활용하여 가변 데이터의 복수 소유자를 만드는 방법을 자세히 살펴봅니다.

---

1. Rc<T>와 RefCell<T>란 무엇인가?

1.1 Rc<T>: 참조 카운팅 스마트 포인터

Rc<T>는 하나의 데이터를 여러 소유자가 공유할 수 있도록 하는 스마트 포인터입니다. 참조 카운트를 유지하여 데이터가 더 이상 사용되지 않을 때 메모리를 안전하게 해제합니다.

주요 특징

• 여러 소유자가 데이터를 공유 가능.
• 불변 데이터에 적합.
• 단일 스레드 환경에서만 사용 가능.

기본 사용 예시

use std::rc::Rc;

let shared_data = Rc::new(5);
let owner1 = Rc::clone(&shared_data);
let owner2 = Rc::clone(&shared_data);

println!("owner1: {}, owner2: {}", owner1, owner2);

---

1.2 RefCell<T>: 런타임 가변성 제공

RefCell<T>는 내부 가변성을 제공하며, 데이터를 런타임에 변경할 수 있게 합니다. 이는 Rust의 불변 참조 규칙을 우회하며 런타임에 가변성을 허용합니다.

주요 특징

• 데이터의 내부 가변성을 허용.
• borrow()와 borrow_mut()를 통해 불변 및 가변 참조를 관리.
• 런타임에 빌림 검사 수행.

기본 사용 예시

use std::cell::RefCell;

let data = RefCell::new(5);
*data.borrow_mut() += 1;
println!("data: {}", data.borrow());

---

2. Rc<T>와 RefCell<T>의 조합

Rc<T>와 RefCell<T>를 조합하면 여러 소유자가 가변 데이터를 공유할 수 있습니다. 이 조합은 특히 재귀 자료구조나 상태를 공유하는 GUI 애플리케이션에서 유용합니다.

2.1 조합의 핵심 아이디어

• Rc<T>: 데이터를 여러 소유자가 공유하도록 허용.
• RefCell<T>: 데이터를 가변적으로 변경할 수 있도록 허용.

동작 원리

1. Rc<T>로 데이터를 감싸 여러 소유자를 생성.
2. RefCell<T>로 내부 가변성을 추가하여 데이터 변경 허용.

간단한 사용 예시

Rc<T>와 RefCell<T>의 조합은 데이터의 공유와 가변성을 동시에 해결합니다. 아래 두 가지 간단한 예제를 통해 이를 자세히 살펴보겠습니다.

예제 1: 카운터 공유

이 예제에서는 Rc<T>로 참조를 공유하고, RefCell<T>를 사용해 카운터 값을 가변적으로 변경합니다. 여러 소유자가 동일한 카운터를 업데이트할 수 있습니다.

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

let counter = Rc::new(RefCell::new(0));

let counter1 = Rc::clone(&counter);
let counter2 = Rc::clone(&counter);

*counter1.borrow_mut() += 1;
*counter2.borrow_mut() += 2;

println!("Counter: {}", counter.borrow()); // 출력: Counter: 3

여기서 counter1과 counter2는 동일한 데이터를 가리키고 있습니다. 각각의 소유자가 borrow_mut을 통해 값을 업데이트하며, 최종적으로 카운터 값은 3이 됩니다.

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

let counter = Rc::new(RefCell::new(0));

let counter1 = Rc::clone(&counter);
let counter2 = Rc::clone(&counter);

*counter1.borrow_mut() += 1;
*counter2.borrow_mut() += 2;

println!("Counter: {}", counter.borrow()); // 출력: Counter: 3

예제 2: 상태 관리

이 예제는 애플리케이션 상태를 관리하는 데 Rc<T>와 RefCell<T>를 사용하는 방법을 보여줍니다. 여러 소유자가 상태를 공유하며, 필요에 따라 값을 업데이트할 수 있습니다.

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

struct AppState {
    value: i32,
}

let state = Rc::new(RefCell::new(AppState { value: 42 }));

let state_ref1 = Rc::clone(&state);
state_ref1.borrow_mut().value += 10;

println!("AppState value: {}", state.borrow().value); // 출력: AppState value: 52

위 코드에서 state_ref1을 통해 상태의 값을 10 증가시킵니다. 최종적으로 state의 값은 52가 됩니다. 이 패턴은 GUI 애플리케이션의 상태 관리에서 자주 사용됩니다.

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

struct AppState {
    value: i32,
}

let state = Rc::new(RefCell::new(AppState { value: 42 }));

let state_ref1 = Rc::clone(&state);
state_ref1.borrow_mut().value += 10;

println!("AppState value: {}", state.borrow().value); // 출력: AppState value: 52

이 간단한 예제들은 Rc<T>와 RefCell<T>를 결합하여 어떻게 데이터를 안전하게 공유하고 수정할 수 있는지 보여줍니다.

---

3. 실전 예제: 간단한 그래프 구현

3.1 문제 상황

노드(Node)가 다른 노드를 참조하는 그래프를 구현해야 하는데, 각 노드는 다른 노드의 리스트를 소유하고, 리스트는 가변적이어야 합니다.

3.2 구현 코드

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

type NodeRef = Rc<RefCell<Node>>;

struct Node {
    value: i32,
    edges: Vec<NodeRef>,
}

impl Node {
    fn new(value: i32) -> NodeRef {
        Rc::new(RefCell::new(Node {
            value,
            edges: vec![],
        }))
    }

    fn add_edge(node: &NodeRef, neighbor: NodeRef) {
        node.borrow_mut().edges.push(neighbor);
    }
}

fn main() {
    let node1 = Node::new(1);
    let node2 = Node::new(2);
    let node3 = Node::new(3);

    Node::add_edge(&node1, Rc::clone(&node2));
    Node::add_edge(&node1, Rc::clone(&node3));

    println!("Node 1 edges: {}", 
        node1.borrow().edges.iter().map(|n| n.borrow().value).collect::<Vec<_>>().join(", "));
}

결과

• 노드 1이 노드 2와 노드 3을 가리키는 그래프 구조가 생성됩니다.

---

4. 장점과 주의사항

4.1 장점

• 안전성: Rc<T>와 RefCell<T>의 조합은 소유권과 가변성을 동시에 제공.
• 유연성: 복잡한 상태를 공유하는 시스템 설계에 적합.

4.2 주의사항

• 런타임 패닉 가능성: RefCell<T>의 빌림 규칙을 위반하면 런타임에 패닉이 발생.
• 성능: Rc<T>와 RefCell<T>는 추가적인 참조 카운팅 및 빌림 검사로 인해 성능 저하 가능.

---

FAQ

Q1: 왜 Rc<T>와 RefCell<T>를 조합해야 하나요?

Rc<T>는 여러 소유권을 가능하게 하지만 불변성만 제공합니다. RefCell<T>를 함께 사용하면 데이터의 가변성을 유지하면서도 여러 소유자가 데이터를 공유할 수 있습니다.

Q2: Rc<T>는 멀티스레드 환경에서 사용할 수 있나요?

Rc<T>는 단일 스레드 환경에서만 사용 가능합니다. 멀티스레드 환경에서는 Arc<T>를 사용해야 합니다.

Q3: RefCell<T>를 남용하면 문제가 생기나요?

RefCell<T>의 빌림 규칙을 위반하면 런타임에 패닉이 발생할 수 있습니다. 따라서 사용 시 신중한 관리가 필요합니다.

---

결론

Rc<T>와 RefCell<T>는 Rust의 강력한 소유권 시스템을 확장하여 가변 데이터를 안전하게 공유할 수 있는 도구를 제공합니다. 특히 복잡한 데이터 구조나 상태 공유가 필요한 애플리케이션에서 이 조합은 필수적입니다. 적절한 사용 사례를 이해하고, 런타임 안전성을 유지하면서 효율적으로 활용해 보세요.

 

References

• https://doc.rust-kr.org/ch15-05-interior-mutability.html

 

• Blandy, J., Orendorff, J., and Tindall, L. F. S. 2021. Programming Rust: Fast, Safe Systems Development. 2nd ed. O'Reilly Media, Sebastopol, CA.
• https://doc.rust-lang.org/book/ch15-05-interior-mutability.html