RustのRc<T>を使った参照カウントスマートポインタの実装と使い方

Rustには、参照カウントスマートポインタの一つであるRc<T>があります。Rc<T>は、複数の所有者を持つオブジェクトのライフタイムを管理するために使用され、Box<T>などのスマートポインタとは異なり、所有権の移動を行いません。

本記事では、Rc<T>の基本的な使い方や注意点について解説し、実際にRc<T>を使って参照カウントスマートポインタを実装する方法についても紹介します。

Rcとは？

Rcの基本的な使い方

use std::rc::Rc;

struct Foo {
    value: i32,
    child: Option<Rc<Foo>>,
}

fn main() {
    let foo1 = Rc::new(Foo { value: 1, child: None });
    let foo2 = Rc::new(Foo { value: 2, child: Some(Rc::clone(&foo1)) });
    let foo3 = Rc::new(Foo { value: 3, child: Some(Rc::clone(&foo2)) });

    println!("foo3: {:?}", foo3);
    println!("foo2: {:?}", foo2);
    println!("foo1: {:?}", foo1);
}

Rcの所有権の共有と循環参照の解決

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

struct Foo {
    parent: Option<Rc<RefCell<Foo>>>,
    value: i32,
}

fn main() {
    let foo1 = Rc::new(RefCell::new(Foo { parent: None, value: 1 }));
    let foo2 = Rc::new(RefCell::new(Foo { parent: Some(Rc::clone(&foo1)), value: 2 }));

    foo1.borrow_mut().parent = Some(Rc::clone(&foo2));
}

use std::rc::Rc;

struct Node {
    value: i32,
    parent: Option<Rc<Node>>,
    children: Vec<Rc<Node>>,
}

impl Node {
    fn new(value: i32) -> Rc<Node> {
        let node = Rc::new(Node {
            value,
            parent: None,
            children: vec![],
        });

        node.parent = Some(Rc::downgrade(&node));
        node
    }

    fn add_child(&mut self, child: Rc<Node>) {
        self.children.push(child);
        child.parent = Some(Rc::downgrade(self));
    }
}

fn main() {
    let node1 = Node::new(1);
    let node2 = Node::new(2);
    node1.add_child(node2);
}

このコードでは、Nodeという構造体を定義し、parentフィールドとchildrenフィールドを持っています。parentフィールドは、親ノードを参照するRc<Node>型のスマートポインタであり、childrenフィールドは、子ノードを格納するVec<Rc<Node>>型のベクターです。

Nodeオブジェクトは、Node::newメソッドを使って作成されます。Node::newメソッドでは、まずRc::newでNodeオブジェクトを生成し、次にRc::downgradeでRc<Node>型のスマートポインタをWeak<Node>型のスマートポインタに変換して、parentフィールドに格納しています。

また、Nodeオブジェクトは、add_childメソッドを使って子ノードを追加できます。add_childメソッドでは、まずself.children.push(child)で子ノードを追加し、次にRc::downgradeでRc<Node>型のスマートポインタをWeak<Node>型のスマートポインタに変換して、child.parentフィールドに格納しています。

このように、Nodeオブジェクトは、親ノードをRc<Node>型のスマートポインタで参照すると同時に、子ノードをVec<Rc<Node>>型のベクターで保持します。このため、循環参照が発生しています。

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

struct Node {
    value: i32,
    parent: Option<Weak<Node>>,
    children: Vec<Rc<Node>>,
}

impl Node {
    fn new(value: i32) -> Rc<Node> {
        let node = Rc::new(Node {
            value,
            parent: None,
            children: vec![],
        });

        node.parent = Some(Rc::downgrade(&node));
        node
    }

    fn add_child(&mut self, child: Rc<Node>) {
        self.children.push(child.clone());
        child.parent = Some(Rc::downgrade(self));
    }
}

fn main() {
    let node1 = Node::new(1);
    let node2 = Node::new(2);
    node1.add_child(node2.clone());

    // node2の親ノードを取得する
    if let Some(parent) = node2.parent.as_ref() {
        if let Some(parent) = parent.upgrade() {
            println!("Parent value: {}", parent.value);
        }
    }
}

このコードでは、NodeオブジェクトのparentフィールドをOption<Weak<Node>>型に変更し、add_childメソッドのchild.parentフィールドにもRc::downgradeを使ってWeak<Node>型のスマートポインタを格納しています。また、parentフィールドの型がOption<Weak<Node>>に変更されたため、親ノードを参照する際には、upgradeメソッドを使ってWeak<Node>型のスマートポインタをRc<Node>型のスマートポインタに変換する必要があります。

参照カウント方式のメモリ効率の向上

use std::rc::Rc;

#[derive(Debug)]
struct Node {
    value: i32,
    next: Option<Rc<Node>>,
}

impl Node {
    fn new(value: i32, next: Option<Rc<Node>>) -> Rc<Node> {
        Rc::new(Node { value, next })
    }
}

fn main() {
    let node1 = Node::new(1, None);
    let node2 = Node::new(2, Some(node1.clone()));
    let node3 = Node::new(3, Some(node2.clone()));
    let node4 = Node::new(4, Some(node3.clone()));
    let node5 = Node::new(5, Some(node4.clone()));
    let node6 = Node::new(6, Some(node5.clone()));
    let node7 = Node::new(7, Some(node6.clone()));
    let node8 = Node::new(8, Some(node7.clone()));
    let node9 = Node::new(9, Some(node8.clone()));
    let node10 = Node::new(10, Some(node9.clone()));

    let root = node10.clone();
    let boxed_root = if Rc::strong_count(&root) == 1 {
        Some(Rc::try_unwrap(root).unwrap())
    } else {
        None
    };
    let boxed_root = match boxed_root {
        Some(node) => Box::new(node),
        None => Box::new((*root).clone()),
    };

    println!("{:?}", boxed_root);
}

このコードでは、Node構造体を定義し、Node::new関数を使って、Rc<Node>型のオブジェクトを作成しています。Node構造体は、valueとnextの2つのフィールドを持ち、nextフィールドは、Option<Rc<Node>>型の参照を持ちます。

main関数では、10個のノードを作成し、root変数に最後のノードを代入しています。そして、Rc::strong_count関数を使って、root変数の参照カウントを取得し、参照カウントが 1 の場合には、Rc::try_unwrap関数を使って、root変数から所有権を取得します。取得した所有権を、Box::new関数を使って、Box<Node>型に変換します。

参照カウントが 1 でない場合には、(*root).clone()でノードをコピーして、Box::new関数を使って、Box<Node>型に変換します。

最後に、boxed_root変数を表示しています。boxed_root変数は、最後のノードを指すBox<Node>型のオブジェクトです。このオブジェクトは、参照カウントが 1 の場合には、Box<Node>型に変換され、参照カウントが 1 でない場合には、Rc<Node>型のオブジェクトとして保持されます。

このように、Rc<T>とBox<T>を使い分けることで、参照カウントが 1 の場合には、Box<T>を使ってメモリ使用量を削減することができます。また、Box<T>は、所有権が単一の場合に使用することが推奨されているため、参照カウントが 1 の場合には、Rc<T>からBox<T>に変換することができます。

なお、この例では、Rc<T>とBox<T>を使い分けることで、メモリ使用量を削減することができますが、使用するデータによっては、効果がない場合もあります。データの特性に応じて、Rc<T>とBox<T>を使い分けることが重要です。

Rcを使ったイベントループの管理

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

struct WindowEventHandler {
    // ウィンドウハンドル
    handle: i32,
    // イベントループに追加するためのハンドル
    event_handler: Rc<RefCell<Option<Box<dyn FnMut()>>>>,
}

impl WindowEventHandler {
    fn new(handle: i32, event_handler: Rc<RefCell<Option<Box<dyn FnMut()>>>>) -> Self {
        WindowEventHandler { handle, event_handler }
    }

    // ウィンドウイベントを受け取るための関数
    fn on_event(&mut self) {
        // イベントハンドラを呼び出す
        if let Some(ref mut event_handler) = *self.event_handler.borrow_mut() {
            event_handler();
        }
    }
}

fn main() {
    // イベントループに追加するためのハンドラ
    let event_handler = Rc::new(RefCell::new(None));

    // ウィンドウイベントを受け取るためのオブジェクトを作成
    let mut window_event_handler = WindowEventHandler::new(1, event_handler.clone());

    // イベントハンドラを設定
    *event_handler.borrow_mut() = Some(Box::new(|| {
        println!("Window event received!");
    }));

    // イベントループを開始
    for i in 0..10 {
        if i == 5 {
            // イベントを受け取る
            window_event_handler.on_event();
        }
    }
}

Rcを使う際の注意点

その１: デッドロックに注意

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

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

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

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

    // 互いに参照し合っているため、デッドロックが発生する
    node1.borrow_mut().next = Some(node2.clone());
    node2.borrow_mut().next = Some(node1.clone());
}

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

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

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

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

    node1.borrow_mut().next = Some(node2.clone());
    node2.borrow_mut().prev = Some(Rc::downgrade(&node1));

    // サイクルは生じず、正常に動作する
}

その２: 意図しないメモリ使用量の増加に注意

use std::rc::Rc;

fn main() {
    let mut rc = Rc::new(0);

    for i in 1..100000 {
        rc = Rc::new(i);
    }

    println!("{}", rc);
}

このコードでは、rcという名前の変数をRc::new(0)で初期化しています。rcは、Rc<i32>型のオブジェクトです。

次に、forループを使って、1から99999までの数値を順にRc::newでラップしています。Rc::newを呼び出すたびに、参照カウントが1ずつ増加し、前のオブジェクトが不要になるたびに参照カウントが1ずつ減少します。

しかし、このコードでは、新しいオブジェクトが生成されるたびに、前のオブジェクトは不要になりますが、参照カウントが1減少する前に、新しいオブジェクトの参照カウントが1増加するため、メモリ使用量が増加します。

実際にこのコードを実行すると、メモリ使用量が急激に増加することが確認できます。このように、Rc<T>を使う場合には、参照カウントの増減を適切に管理し、メモリ使用量が増加しないように注意する必要があります。

Rcの代替となるスマートポインタについて

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

struct Counter {
    value: i32,
}

impl Counter {
    fn new(value: i32) -> Counter {
        Counter { value }
    }

    fn increment(&mut self) {
        self.value += 1;
    }

    fn get_value(&self) -> i32 {
        self.value
    }
}

fn main() {
    let counter = Arc::new(Counter::new(0));

    let mut threads = Vec::new();

    for _ in 0..10 {
        let counter = Arc::clone(&counter);

        let thread = thread::spawn(move || {
            let mut counter = counter.lock().unwrap();
            counter.increment();
        });

        threads.push(thread);
    }

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

    println!("{}", counter.get_value());
}

以上が、Rc<T>の代替となるスマートポインタであるArc<T>についての解説です。Arc<T>は、Rc<T>と比べてスレッドセーフであるため、スレッドセーフなコードを書く場合には、Arc<T>を使うことが推奨されています。