Rustのマルチスレッド性能向上：Arc最適化テクニック

[![表紙](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/4f259c1a-c8b6-4797-90d9-5c5cb63f31cf.png)](https://leapcell.io/?lc_t=q_rustarc)

Rust プログラミングにおいて、Arc（原子参照カウント）とミューテックス（例：Mutex）を組み合わせて使用するのは、マルチスレッド環境でデータを共有・変更するための一般的なパターンです。しかし、この方法は特にロック競合が激しい状況下でパフォーマンスのボトルネックとなる可能性があります。本記事では、ロック競合を減らしパフォーマンスを向上させながらスレッドセーフを維持するためのいくつかの最適化手法を検討します。例えば、以下の例があります：

## 細粒度のロックの使用

性能を向上させる一つの方法は、より細粒度のロックを使用することです。これは、データ構造を複数の部分に分解し、それぞれに独自のロック機構を持たせることで実現できます。例えば、Mutex の代わりに RwLock を使用することで、読み取り操作が書き込み操作よりもはるかに多い場合に効率を向上させることができます。サンプルコードでは、データ構造 T の各部分をそれぞれ独自の RwLock に配置する方法を示しており、それによりこれらの部分を個別にロックおよびアンロックできるようになっています。

```rust
use std::sync::{Arc, RwLock};
use std::thread;

// 仮に T は2つの部分を含む複雑なデータ構造とする
struct T {
    part1: i32,
    part2: i32,
}

// T の各部分をそれぞれ RwLock に入れる
struct SharedData {
    part1: RwLock<i32>,
    part2: RwLock<i32>,
}

// この関数はデータへの頻繁なアクセスと変更をシミュレートする
fn frequent_access(data: Arc<SharedData>) {
    {
        // 変更が必要な部分のみをロックする
        let mut part1 = data.part1.write().unwrap();
        *part1 += 1; // part1 を変更する
    } // part1 のロックはここで解除される

    // 他の部分の読み取りまたは書き込み操作も同時に行うことができる
    // ...
}

fn main() {
    let data = Arc::new(SharedData {
        part1: RwLock::new(0),
        part2: RwLock::new(0),
    });

    // 複数のスレッドを作成して共有データへのアクセスを実演する
    let mut handles = vec![];
    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            frequent_access(data_clone);
        });
        handles.push(handle);
    }

    // 全てのスレッドの完了を待つ
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final values: Part1 = {}, Part2 = {}",
             data.part1.read().unwrap(),
             data.part2.read().unwrap());
}
```

この例では、`std::sync::RwLock` を使用してより細粒度なロックを実現しています。RwLock は複数の読み取り者または 1 人の書き込み者を許可するため、読み取り操作が書き込み操作よりもはるかに多いシナリオで非常に有用です。この例では、T の各部分をそれぞれ独自の RwLock に配置しています。これにより、各部分を個別にロックすることが可能となり、スレッドセーフ性を損なうことなくパフォーマンスを向上させることができます。ある部分が変更されると、その部分のロックのみが占有され、他の部分は他のスレッドによって読み取りまたは書き込みが可能です。

この方法は、データ構造を相対的に独立した部分に明確に分解できる場合に適用できます。このようなシステムを設計する際には、データの一貫性やデッドロックのリスクについて慎重に検討する必要があります。

## データのクローンとロック保持時間の短縮

もう一つの方法は、データを変更する前にクローンを作成し、共有データを更新する際にのみロックを取得することです。この方法では、ロックの保持時間を減らすことでパフォーマンスを向上させます。具体的には、ロックの外でデータをクローンし、そのクローンに対してロックなしで変更を加え、最終的に必要な時だけロックを再取得して共有データを更新します。これによりロックの競合が減り、他のスレッドがより早く共有リソースにアクセスできるようになります。

```rust
use std::sync::{Arc, Mutex};
use std::thread;

// 仮に T はクローン可能な複雑なデータ構造とする
#[derive(Clone)]
struct T {
    value: i32,
}

// この関数はデータへの頻繁なアクセスと変更をシミュレートする
fn frequent_access(data: Arc<Mutex<T>>) {
    // ロックの外でデータをクローン
    let mut data_clone = {
        let data_locked = data.lock().unwrap();
        data_locked.clone()
    };

    // クローンしたデータを変更
    data_clone.value += 1;

    // 共有データを更新する時のみロックを取得
    let mut data_shared = data.lock().unwrap();
    *data_shared = data_clone;
}

fn main() {
    let data = Arc::new(Mutex::new(T { value: 0 }));

    // 複数のスレッドを作成して共有データへのアクセスを実演する
    let mut handles = vec![];
    for _ in 0..10 {
        let data_clone = Arc::clone(&data);
        let handle = thread::spawn(move || {
            frequent_access(data_clone);
        });
        handles.push(handle);
    }

    // 全てのスレッドの完了を待つ
    for handle in handles {
        handle.join().unwrap();
    }

    println!("Final value: {}", data.lock().unwrap().value);
}
```

このコードの目的は、ミューテックス（`Mutex`）の保持時間を減らすことでパフォーマンスを向上させることです。そのプロセスを順を追って説明します：

### 1. ロックの外でデータをクローン

```rust
let mut data_clone = {
    let data_locked = data.lock().unwrap();
    data_locked.clone()
};
```

ここでは、まず `data.lock().unwrap()` を使って `data` のロックを取得し、直後にそのデータをクローンしています。このクローン操作が終わると `{}` のスコープが終了するため、ロックは自動的に解放されます。つまり、クローンしたデータを操作する際には、元の `data` にロックがかかっていません。

### 2. クローンデータの変更

```rust
data_clone.value += 1;
```

`data_clone` は `data` のコピーなので、ここではロックなしで自由に変更できます。これがパフォーマンス向上の重要なポイントです。つまり、計算や処理の間 `Mutex` を保持しないことで、他のスレッドが待機する時間を減らします。

### 3. 共有データを更新する時のみロックを取得

```rust
let mut data_shared = data.lock().unwrap();
*data_shared = data_clone;
```

変更が完了した後、再度 `data` のロックを取得し、クローンした `data_clone` の内容を `data` に代入します。この操作は最小限の時間しかロックを保持しないため、スレッド間の競合が減り、システムのスループットが向上します。

この方法の利点は、ロックの競合を減らすことで並行性を向上させることです。特に、データの計算や変更に時間がかかる場合、長時間ロックを保持せずに処理できるため、全体のスループットが大幅に改善される可能性があります。

しかし、この手法にはデメリットもあります。例えば：

1. **メモリ消費の増加**  
   クローンを作成するため、一時的に余分なメモリを消費することになります。これは大きなデータ構造の場合、コストがかかる可能性があります。
2. **同期ロジックの複雑化**  
   クローンを作成しながら更新を行うため、適切なタイミングで共有データに反映しなければならず、コードの複雑度が増します。

したがって、この方法を使用するかどうかは、システムの具体的な要件やボトルネックを慎重に分析した上で決定する必要があります。

---

### [私たちはLeapcell、Rustプロジェクトのホスティングの最適解です。](https://leapcell.io/?lc_t=q_rustarc)

[![Leapcell](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/9070900f-9838-46f2-9cde-ad5195a47549.png)](https://leapcell.io/?lc_t=q_rustarc)

[Leapcell](https://leapcell.io/?lc_t=q_rustarc)は、Webホスティング、非同期タスク、Redis向けの次世代サーバーレスプラットフォームです：

**複数言語サポート**

- Node.js、Python、Go、Rustで開発できます。

**無制限のプロジェクトデプロイ**

- 使用量に応じて料金を支払い、リクエストがなければ料金は発生しません。

**比類のないコスト効率**

- 使用量に応じた支払い、アイドル時間は課金されません。
- 例: $25で6.94Mリクエスト、平均応答時間60ms。

**洗練された開発者体験**

- 直感的なUIで簡単に設定できます。
- 完全自動化されたCI/CDパイプラインとGitOps統合。
- 実行可能なインサイトのためのリアルタイムのメトリクスとログ。

**簡単なスケーラビリティと高パフォーマンス**

- 高い同時実行性を容易に処理するためのオートスケーリング。
- ゼロ運用オーバーヘッド — 構築に集中できます。

[ドキュメントで詳細を確認！](https://docs.leapcell.io/)

[![Try Leapcell](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/ceb76429-1cfe-47b6-a578-d11efc8516f2.png)](https://leapcell.io/?lc_t=q_rustarc)

Xでフォローする：[@LeapcellHQ](https://x.com/LeapcellHQ)

---

[ブログでこの記事を読む](https://leapcell.io/blog/enhancing-multithreading-in-rust)