RustのOrderingを活用して信頼性の高い並行処理を実現する

[![表紙](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/bdf2fd1c-1bd2-4f51-9e5c-6bc4e6b13cef.png)](https://leapcell.io/?lc_t=q_rustordering)

並行プログラミングにおいて、メモリ操作の順序を正しく管理することは、プログラムの正確性を保証する上で重要な鍵となります。Rust は、アトミック操作とメモリ順序（Ordering）列挙型を提供することで、開発者がマルチスレッド環境で安全かつ効率的に共有データを操作できるようにしています。本記事では、Rust における Ordering の原理と使用方法を詳しく解説し、開発者がこの強力なツールをより深く理解し、適切に活用できるようにすることを目的とします。

## メモリ順序の基礎

現代のプロセッサやコンパイラは、パフォーマンスを最適化するために、命令やメモリ操作を並べ替えることがあります。このような並べ替えは、単一スレッドのプログラムでは問題にならないことが多いですが、マルチスレッド環境では、適切に制御しないとデータ競合や状態の不整合が発生する可能性があります。この問題を解決するために「メモリ順序」という概念が導入されました。アトミック操作に対してメモリ順序を指定することで、並行環境におけるメモリアクセスの適切な同期を確保できます。

## Rust における Ordering 列挙型

Rust の標準ライブラリには、異なるレベルのメモリ順序を保証するための Ordering 列挙型が用意されています。開発者は具体的なニーズに応じて適切な順序モデルを選択できます。以下は Rust で利用可能なメモリ順序オプションです。

### Relaxed

`Relaxed` は最も基本的な保証を提供します。それは、単一のアトミック操作のアトミシティ（不可分性）を保証するものの、操作間の順序を保証しません。この順序は、操作の相対的な順序がプログラムの正確性に影響を与えない、単純なカウンタや状態マーカーの用途に適しています。

### Acquire と Release

`Acquire` と `Release` は、操作間の部分的な順序関係を制御するために使用されます。

- `Acquire` は、現在のスレッドが後続の操作を実行する前に、それに対応する `Release` 操作によって行われた変更を確実に可視化することを保証します。
- `Release` は、あるスレッドがデータを更新した後、その変更が他のスレッドから確実に見えるようにするために使用されます。

この順序は、ロックやその他の同期プリミティブを実装する際に一般的に使用され、リソースが適切に初期化されることを保証します。

### AcqRel

`AcqRel` は `Acquire` と `Release` の両方の効果を組み合わせたものです。これは、値を読み込みつつ修正する必要がある操作に適しており、他のスレッドとの間で操作の順序を確保するのに役立ちます。

### SeqCst

`SeqCst`（Sequentially Consistent、逐次一貫性）は、最も強力な順序保証を提供します。これは、すべてのスレッドが操作を同じ順序で見ることを保証し、グローバルな実行順序が求められる場面で使用されます。

## Ordering の実践的な使用

適切な `Ordering` を選択することが重要です。順序を緩くしすぎるとプログラムのロジックにエラーが生じる可能性があり、逆に厳しすぎると不要なパフォーマンス低下を招くことがあります。以下に、`Ordering` を活用した Rust のコード例を紹介します。

### 例 1：Relaxed を使用した順序のないカウンタ操作

この例では、`Relaxed` を使用してマルチスレッド環境で単純なカウント操作を行う方法を示します。

```rust
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

let counter = AtomicUsize::new(0);

thread::spawn(move || {
    counter.fetch_add(1, Ordering::Relaxed);
}).join().unwrap();

println!("Counter: {}", counter.load(Ordering::Relaxed));
```

- `AtomicUsize` 型の原子カウンタ `counter` を作成し、0 に初期化します。
- `thread::spawn` で新しいスレッドを作成し、その中で `fetch_add` を使ってカウンタの値を 1 増やします。
- `Ordering::Relaxed` を使用すると、この増加操作はアトミック（不可分）に行われますが、操作の順序性は保証されません。つまり、複数のスレッドが同時に `fetch_add` を実行しても安全に加算されますが、それらの実行順序は不確定です。
- `Relaxed` は、カウント操作の順序が問題にならない場合に適しています。

### 例 2：Acquire と Release を使用したデータアクセスの同期

この例では、`Acquire` と `Release` を使用して 2 つのスレッド間でデータのアクセスを同期する方法を示します。

```rust
use std::sync::{Arc, atomic::{AtomicBool, Ordering}};
use std::thread;

let data_ready = Arc::new(AtomicBool::new(false));
let data_ready_clone = Arc::clone(&data_ready);

// 生産者スレッド（Producer）
thread::spawn(move || {
    // データの準備
    // ...
    data_ready_clone.store(true, Ordering::Release);
});

// 消費者スレッド（Consumer）
thread::spawn(move || {
    while !data_ready.load(Ordering::Acquire) {
        // データが準備されるまで待機
    }
    // 生産者が準備したデータに安全にアクセス
});
```

- `AtomicBool` 型の `data_ready` フラグを作成し、データがまだ準備されていないことを示す `false` に初期化します。
- `Arc` を使用して `data_ready` を複数のスレッド間で安全に共有します。
- 生産者スレッドはデータを準備した後、`store(true, Ordering::Release)` を呼び出して `data_ready` を `true` に設定します。
  - `Ordering::Release` を指定することで、このスレッドが行ったすべての書き込みが、他のスレッドから確実に見えるようになります。
- 消費者スレッドは `load(Ordering::Acquire)` を使用して `data_ready` の値をチェックします。
  - `Ordering::Acquire` により、`data_ready` が `true` になる前に行われた書き込み（データ準備の処理）が、現在のスレッドから確実に見えるようになります。

このように、`Acquire` と `Release` を組み合わせることで、マルチスレッド環境で安全なデータのやり取りを実現できます。

### 例 3：AcqRel を使用した読み書き操作の同期

この例では、`AcqRel` を使用して、値を読みつつ変更する操作を正しく同期させる方法を示します。

```rust
use std::sync::{Arc, atomic::{AtomicUsize, Ordering}};
use std::thread;

let some_value = Arc::new(AtomicUsize::new(0));
let some_value_clone = Arc::clone(&some_value);

// 変更スレッド
thread::spawn(move || {
    // fetch_add は値を読み取りつつ変更するため、AcqRel を使用
    some_value_clone.fetch_add(1, Ordering::AcqRel);
}).join().unwrap();

println!("some_value: {}", some_value.load(Ordering::SeqCst));
```

- `AcqRel` は `Acquire` と `Release` の両方の意味を持ちます。
  - `fetch_add` は、現在の値を読み込んで変更し、その新しい値を書き戻す操作です。この場合、`Ordering::AcqRel` を使用することで、
    - 読み取り時に過去の変更をすべて反映（`Acquire`）
    - 書き込み時に後続の操作に変更が正しく見えるようにする（`Release`）  
      という順序制約を確保します。
- `fetch_add` の後に `SeqCst` を使って値を読み込むことで、変更後の結果を確実に確認できます。

### 例 4：SeqCst を使用した全体的な順序保証

この例では、`SeqCst` を使用して操作の全体的な順序を保証する方法を示します。

```rust
use std::sync::atomic::{AtomicUsize, Ordering};
use std::thread;

let counter = AtomicUsize::new(0);

thread::spawn(move || {
    counter.fetch_add(1, Ordering::SeqCst);
}).join().unwrap();

println!("Counter: {}", counter.load(Ordering::SeqCst));
```

- 例 1 と同様に、`AtomicUsize` を使ってカウンタを管理します。
- `Relaxed` ではなく `SeqCst` を使用することで、操作のグローバルな順序が保証されます。
- `SeqCst` は最も強力な順序保証を提供し、すべてのスレッドが操作を同じ順序で観測することを保証します。  
  これは、時間同期、ゲーム内のプレイヤー同期、状態マシンの同期など、操作の順序が重要な場面で役立ちます。

## まとめ

Rust における `Ordering` は、マルチスレッド環境での安全なメモリアクセスを可能にする強力なツールです。適切な `Ordering` を選択することで、プログラムの正確性を保ちつつ、不要なパフォーマンスの低下を防ぐことができます。

- **Relaxed**: 単なるアトミック性が必要な場合に使用
- **Acquire/Release**: スレッド間のデータ同期を保証
- **AcqRel**: 読み書きを同時に行うアトミック操作に使用
- **SeqCst**: グローバルな順序整合性を保証する最も強力なオプション

並行プログラミングでは、パフォーマンスと安全性のバランスを考慮しながら、適切な `Ordering` を選択することが重要です。Rust の提供するメモリ順序機能を活用し、安全で効率的なマルチスレッドプログラミングを実現しましょう。

---

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

[![Leapcell](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/3967621/56e6c8d2-9454-48ee-8f7b-4407bad8aa14.png)](https://leapcell.io/?lc_t=q_rustordering)

[Leapcell](https://leapcell.io/?lc_t=q_rustordering)は、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/be63757c-1368-4ede-8055-359e8fb0a9e6.png)](https://leapcell.io/?lc_t=q_rustordering)

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

---

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