MENU
  1. ホーム
  2. Rust
  3. RustのSendとSyncトレイトでスレッドセーフを徹底解説：安全な並列処理を実現する方法

RustのSendとSyncトレイトでスレッドセーフを徹底解説：安全な並列処理を実現する方法

Rust

Rustの並列処理は、高速で安全なプログラムを構築するために設計されています。その中でも特に重要な要素がSendとSyncトレイトです。これらのトレイトは、Rustの所有権システムとライフタイムを活用し、データ競合や未定義動作を防ぎます。本記事では、SendとSyncトレイトの基本的な役割、適用範囲、実際の使用例を通じて、Rustにおけるスレッドセーフ性の理解を深めます。スレッドセーフなプログラムの実装を目指す方にとって、不可欠な知識を詳細に解説します。

目次

Rustの並列処理とスレッドセーフの基本


Rustは、安全性とパフォーマンスを両立するプログラミング言語として設計されています。その特徴の一つが、並列処理を安全に実現するためのスレッドセーフ性の保証です。スレッドセーフ性とは、複数のスレッドが同時にプログラムを実行する場合でも、データ競合や未定義動作が発生しない性質を指します。

所有権システムが支える安全性


Rustでは、データ競合を防ぐために所有権システムが基本にあります。一つのスレッドがデータの所有権を持つ場合、他のスレッドはそのデータにアクセスできません。このシステムはコンパイル時に検証され、潜在的なエラーを未然に防ぎます。

スレッドセーフの鍵となる`Send`と`Sync`


Rustのスレッドセーフ性を支える主要な要素が、SendとSyncトレイトです。

  • Sendトレイト: データの所有権をスレッド間で安全に移動できることを示します。
  • Syncトレイト: 同時に複数のスレッドから参照できることを保証します。

これらのトレイトを自動的に適用する仕組みによって、開発者は安全性を意識することなく並列処理を実現できます。

スレッドセーフを実現する目的


Rustのスレッドセーフ性は、以下の目標を達成するために設計されています。

  1. データ競合の排除: メモリの整合性を保証する。
  2. パフォーマンスの最適化: スレッド間の干渉を最小化し効率を向上させる。
  3. 開発者体験の向上: コンパイル時にエラーを検知することで、デバッグの負担を軽減する。

Rustの並列処理は、これらの目標を満たしながら安全でパフォーマンスに優れたコードを書くための基盤を提供します。

`Send`トレイトの役割と適用範囲

RustのSendトレイトは、所有権を異なるスレッドに安全に移動できることを保証する重要なトレイトです。このトレイトを理解することで、並列処理におけるデータ管理がより明確になります。

`Send`トレイトの基本的な役割


Sendトレイトは、ある型がスレッド間で所有権を移動できるかどうかを示します。たとえば、Sendを実装している型の値は、スレッドプールなどの並列処理環境で利用することが可能です。これにより、スレッド間でデータを安全にやり取りできます。

デフォルトで`Send`を持つ型


以下の型は、デフォルトでSendトレイトを実装しています。

  • 整数型（i32, u64 など）
  • 浮動小数点型（f64, f32 など）
  • 標準ライブラリのStringやVec<T>などのコレクション型（内部がスレッドセーフである場合）

`Send`トレイトが自動で適用されない場合


Sendトレイトは、データの安全性が保証できない場合には適用されません。特に以下のケースではSendが適用されないため注意が必要です。

  1. 非スレッドセーフな型を含む場合
    例: Rc<T>（参照カウント型）は非スレッドセーフなため、Sendを実装していません。
  2. 低レベル操作を含む型
    例: UnsafeCell<T>（安全でないメモリ操作を許容）を含む型もSendではありません。

具体的な例: スレッド間のデータ所有権の移動


以下に、Sendトレイトを利用した具体例を示します。

use std::thread;

fn main() {
    let data = String::from("Hello, Rust!");
    let handle = thread::spawn(move || {
        println!("{}", data);
    });

    handle.join().unwrap();
}

このコードでは、dataの所有権がmoveキーワードを使って新しいスレッドに移動します。String型はSendを実装しているため、この操作が安全に行えます。

`Send`トレイトのメリット

  • 所有権システムと連携: Rustの所有権システムに基づき、スレッド間で安全にデータをやり取りできる。
  • 自動導出: 安全な型に対しては自動的にSendが適用され、開発者が意識しなくても利用可能。

Sendトレイトは、スレッドセーフなプログラム設計における基盤となる機能を提供します。次は、参照の共有を保証するSyncトレイトについて解説します。

`Sync`トレイトの役割と適用範囲

RustのSyncトレイトは、同じデータを複数のスレッドから同時に参照できる安全性を保証するためのトレイトです。このトレイトを理解することで、並列処理におけるデータ共有がどのように管理されているかが明確になります。

`Sync`トレイトの基本的な役割


Syncトレイトは、型が複数のスレッドから同時に不変参照されても問題がないことを示します。Rustでは、この保証がある型だけがスレッド間で共有されることを許されます。

デフォルトで`Sync`を持つ型


以下の型は、デフォルトでSyncトレイトを実装しています。

  • 整数型（i32, u64 など）
  • 浮動小数点型（f32, f64 など）
  • 不変データ（&T）
    これらの型は変更される心配がないため、安全に共有できます。

`Sync`トレイトが適用されない場合


Syncトレイトは、データの共有が安全に保証できない場合には適用されません。特に以下のケースではSyncが適用されないため注意が必要です。

  1. 内部で可変状態を持つ場合
    例: Cell<T>やRefCell<T>は、内部で可変性を持つためスレッドセーフではなく、Syncトレイトを実装していません。
  2. 外部リソースを操作する型
    例: RawPointer（生ポインタ）を操作する場合も、スレッド間で共有すると未定義動作が発生する可能性があります。

具体的な例: スレッド間のデータ共有


以下に、Syncトレイトを利用した具体例を示します。

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

fn main() {
    let data = Arc::new(42);

    let threads: Vec<_> = (0..5).map(|_| {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            println!("Data: {}", *data);
        })
    }).collect();

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

この例では、Arc<T>（スレッドセーフな参照カウント型）を使用して、複数のスレッド間でデータを共有しています。Arc<T>はSyncトレイトを実装しているため、安全に共有可能です。

`Sync`トレイトのメリット

  • 参照の共有を保証: スレッド間でデータの整合性を保ちながら共有が可能。
  • 不変データの活用: 不変性を前提とした安全な並列処理を実現。
  • 標準ライブラリとの統合: Arc<T>やMutex<T>など、多くの標準ライブラリ型がSyncをサポート。

`Send`と`Sync`の組み合わせ


Rustでは、多くの型がSendとSyncの両方を実装しています。これにより、データの所有権移動と参照の共有を組み合わせた柔軟なスレッドセーフ設計が可能です。

次は、SendとSyncトレイトがどのように自動導出されるかを解説します。

`Send`と`Sync`のトレイト自動導出

Rustでは、多くの型に対してSendとSyncトレイトが自動的に適用されます。この仕組みは、スレッドセーフ性を確保しながら、開発者の手間を大幅に削減するものです。ここでは、トレイトの自動導出の仕組みとその利点について解説します。

トレイトの自動導出とは


SendとSyncトレイトは、型の安全性に基づいてコンパイラによって自動的に実装されます。この仕組みにより、開発者が特別な操作をしなくても多くの場合においてスレッドセーフな型を利用できます。

自動導出される条件

  • 型が他の型を内包する場合: 内包される型がSendまたはSyncであれば、外側の型も自動的にこれらのトレイトを実装します。
  • 不変データのみを扱う場合: 不変データはスレッドセーフであるため、SendとSyncの導出対象となります。

例: 以下の型は自動導出されます。

struct MyStruct {
    a: i32,
    b: String,
}

fn main() {
    let _x: MyStruct = MyStruct { a: 10, b: String::from("Hello") };
    // MyStructはSendとSyncが自動導出される
}

自動導出されないケース


以下の場合は、自動導出が行われません。

  1. スレッドセーフでない型を含む場合
  • 例: Rc<T>（スレッドセーフではない参照カウント型）を含む型。
   use std::rc::Rc;
   struct NotSendOrSync {
       data: Rc<i32>,
   }

この場合、手動で安全性を担保しなければならないか、型を変更する必要があります。

  1. 低レベルの型や安全性が検証できない場合
  • 例: UnsafeCell<T>（内部可変性を持つ型）を含む型。

カスタム型における例外的な実装


場合によっては、unsafeを使用してトレイトを手動で実装することも可能です。ただし、これは自己責任で行う必要があります。

unsafe impl Send for MyType {}
unsafe impl Sync for MyType {}

この手法は、型がスレッドセーフであることを開発者が完全に理解している場合にのみ利用します。

トレイト自動導出の利点

  • 開発効率の向上: 多くの型で明示的なトレイト実装が不要。
  • 安全性の確保: コンパイラが自動的にトレイトを適用するため、ミスを防ぐことができる。
  • コードの簡潔化: 不必要なトレイト実装コードを排除。

導出される型を確認する方法


Rustでは、型がSendまたはSyncを実装しているかどうかを簡単に確認する方法があります。以下のコードを使うことで、実装状態を確認できます。

fn is_send<T: Send>() {}
fn is_sync<T: Sync>() {}

fn main() {
    is_send::<i32>(); // コンパイルが通ればSendを実装
    is_sync::<i32>(); // コンパイルが通ればSyncを実装
}

この仕組みを理解することで、Rustの所有権とスレッドセーフ性を活用した効率的なプログラム設計が可能になります。次は、カスタム型におけるSendとSyncの実装例を詳しく解説します。

カスタム型における`Send`と`Sync`の実装例

Rustでは、多くの標準型がSendとSyncを自動的に実装しますが、カスタム型においては場合によって手動でこれらのトレイトを実装する必要があります。ここでは、カスタム型におけるSendとSyncの実装例と注意点を解説します。

基本的なカスタム型での自動導出


カスタム型が標準ライブラリ型やスレッドセーフな型のみを内包している場合、SendとSyncは自動で適用されます。

struct MyStruct {
    a: i32,
    b: String,
}

fn main() {
    let _instance = MyStruct { a: 10, b: String::from("Hello") };
    // MyStructは`Send`と`Sync`を自動的に実装している
}

この場合、i32とStringがSendとSyncをサポートしているため、MyStructもトレイトを自動導出します。

非スレッドセーフ型を含む場合のカスタム型


非スレッドセーフな型（例: Rc<T>）を含む場合、カスタム型はSendやSyncを自動で実装しません。この場合、安全性を確保する方法を検討する必要があります。

use std::rc::Rc;

struct NotSendOrSync {
    data: Rc<i32>,
}

// この型は`Send`と`Sync`を実装しない

手動による`Send`と`Sync`の実装


安全性を保証できる場合、SendとSyncを手動で実装できます。ただし、これはunsafeを使用するため、非常に慎重な検討が必要です。

use std::cell::UnsafeCell;

struct MySafeType {
    data: UnsafeCell<i32>,
}

// 手動でSendとSyncを実装
unsafe impl Send for MySafeType {}
unsafe impl Sync for MySafeType {}

fn main() {
    let my_safe_type = MySafeType {
        data: UnsafeCell::new(42),
    };
    // 使用例...
}

この例では、UnsafeCellを含む型に対してSendとSyncを手動で実装しています。このコードが安全であることを開発者自身が保証しなければなりません。

注意点: スレッドセーフ性を損なわない設計


SendやSyncを手動で実装する際は、以下の点に注意してください。

  1. 可変状態の管理
    型が内部で可変状態を持つ場合、データ競合が発生しないよう十分に配慮する必要があります。
  2. 非スレッドセーフ型のラップ
    非スレッドセーフ型を含む場合は、Arc<T>やMutex<T>などのスレッドセーフ型でラップすることを検討します。

具体例: スレッドセーフな型の設計

以下は、非スレッドセーフ型をArcでラップして安全に共有する例です。

use std::sync::{Arc, Mutex};

struct MySafeStruct {
    data: Arc<Mutex<i32>>,
}

fn main() {
    let instance = MySafeStruct {
        data: Arc::new(Mutex::new(42)),
    };

    let cloned = Arc::clone(&instance.data);
    std::thread::spawn(move || {
        let mut data = cloned.lock().unwrap();
        *data += 1;
        println!("Updated data: {}", *data);
    }).join().unwrap();
}

この設計では、ArcとMutexを活用することで安全性を保ちながらスレッド間でデータを共有しています。

まとめ


カスタム型でSendとSyncを扱う際は、以下のアプローチが重要です。

  • 自動導出が可能な場合はコンパイラに任せる。
  • 必要に応じてスレッドセーフ型でラップする。
  • 手動実装は慎重に行い、安全性を徹底的に検証する。

これらの実践により、安全で効率的なスレッドセーフなカスタム型を設計することが可能です。次は、非スレッドセーフな型を扱う方法について解説します。

非スレッドセーフな型の扱い方

Rustでは、非スレッドセーフな型を直接並列処理で使用することは推奨されていません。しかし、特定の状況ではこれらの型をスレッド間で扱う必要が生じる場合があります。その際には、安全性を確保するための工夫が求められます。ここでは、非スレッドセーフな型を適切に管理する方法を解説します。

非スレッドセーフな型の例


以下の型は、デフォルトでSendやSyncトレイトを実装しておらず、非スレッドセーフとして扱われます。

  • Rc<T>: スレッド間での参照カウントは安全ではありません。
  • RefCell<T>: 内部可変性を持つ型で、データ競合が発生する可能性があります。
  • UnsafeCell<T>: 低レベルで可変なデータを操作します。

例として、以下のコードは非スレッドセーフです。

use std::rc::Rc;

fn main() {
    let data = Rc::new(42);
    // Rc型はSendを実装していないため、スレッド間で安全に使用できません
}

スレッドセーフ型でラップする


非スレッドセーフな型を安全に使用するには、スレッドセーフな型でラップする方法が一般的です。例えば、Arc<T>（スレッドセーフな参照カウント型）やMutex<T>（データの排他制御を提供する型）を使用します。

use std::sync::{Arc, Mutex};

fn main() {
    let data = Arc::new(Mutex::new(42));

    let cloned_data = Arc::clone(&data);
    std::thread::spawn(move || {
        let mut value = cloned_data.lock().unwrap();
        *value += 1;
    }).join().unwrap();

    println!("Data: {}", *data.lock().unwrap());
}

ここでは、ArcとMutexを使用して、Rc型の代替としてスレッドセーフなデータ共有を実現しています。

非スレッドセーフ型の内部ラップ


非スレッドセーフ型を使用したい場合は、内部で安全に管理するラッパー型を設計することも可能です。

use std::sync::Mutex;

struct SafeRc {
    data: Mutex<i32>,
}

fn main() {
    let safe_rc = SafeRc {
        data: Mutex::new(42),
    };

    {
        let mut value = safe_rc.data.lock().unwrap();
        *value += 1;
    }

    println!("Updated data: {:?}", safe_rc.data.lock().unwrap());
}

この例では、Mutexを使ってi32をラップすることで安全性を確保しています。

`unsafe`を用いた慎重な実装


非スレッドセーフ型をunsafeブロックで強制的に使用することも可能ですが、この方法は安全性を確保するために非常に注意が必要です。

use std::cell::UnsafeCell;

struct MyUnsafeType {
    data: UnsafeCell<i32>,
}

unsafe impl Send for MyUnsafeType {}
unsafe impl Sync for MyUnsafeType {}

fn main() {
    let my_data = MyUnsafeType {
        data: UnsafeCell::new(42),
    };

    unsafe {
        *my_data.data.get() += 1;
        println!("Updated data: {}", *my_data.data.get());
    }
}

このコードでは、UnsafeCellを利用して可変データを扱っていますが、データ競合を防ぐための徹底した管理が必要です。

注意点とベストプラクティス


非スレッドセーフな型を扱う際には、以下の注意点を守ることが重要です。

  1. スレッドセーフ型でラップ: ArcやMutexを使用して安全性を確保する。
  2. unsafeの使用を最小限に: 必要な場合に限定して慎重に利用する。
  3. データ競合の回避: 排他制御やライフタイム管理を徹底する。

これらの方法を実践することで、非スレッドセーフな型を安全に活用することが可能になります。次は、スレッドセーフな並列処理の応用例を紹介します。

応用例：マルチスレッド環境での`Mutex`と`Arc`の活用

Rustでは、SendとSyncトレイトを活用してスレッドセーフな並列処理を実現できます。その中でも、MutexとArcを組み合わせることで、複数のスレッド間で共有されるデータを安全に管理することが可能です。このセクションでは、具体的なコード例を通じてその実践的な使い方を解説します。

基本例: スレッド間での共有カウンター

以下の例は、複数のスレッドが共有するカウンターを安全に更新する方法を示しています。

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

fn main() {
    // 共有カウンターを`Arc`と`Mutex`でラップ
    let counter = Arc::new(Mutex::new(0));

    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1; // カウンターをインクリメント
        });
        handles.push(handle);
    }

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

    println!("Final counter value: {}", *counter.lock().unwrap());
}

このコードでは以下を実現しています：

  • Arc（Atomic Reference Counted）: 複数のスレッド間で共有するデータを安全に管理します。
  • Mutex（Mutual Exclusion）: 同時に一つのスレッドだけがデータを操作できるように制御します。

応用例: 並列処理でのデータ集計

次に、複数のスレッドで配列の一部を処理し、結果を集計する例を示します。

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

fn main() {
    let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let sum = Arc::new(Mutex::new(0));

    let mut handles = vec![];

    for chunk in data.chunks(2) {
        let sum = Arc::clone(&sum);
        let chunk = chunk.to_vec();
        let handle = thread::spawn(move || {
            let partial_sum: i32 = chunk.iter().sum();
            let mut total_sum = sum.lock().unwrap();
            *total_sum += partial_sum; // 部分和を加算
        });
        handles.push(handle);
    }

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

    println!("Total sum: {}", *sum.lock().unwrap());
}

この例では、データを分割して並列処理し、最終的な合計値を集計しています。Mutexがスレッド間での安全な書き込みを保証しています。

パフォーマンス向上のための注意点


並列処理でMutexとArcを使用する場合、以下の点に注意すると効率が向上します。

  1. ロック時間を短縮: 可能な限り短時間でMutexのロックを解除する。
  2. データの分割: データを分割して独立したスレッドで処理を行う。
  3. ロックの競合回避: ロックの競合を減らす設計を心がける。

さらに高度な応用例: コンカレントハッシュマップ

複数スレッドから安全にアクセスできるデータ構造の一例として、HashMapをMutexで保護する方法を紹介します。

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::thread;

fn main() {
    let map = Arc::new(Mutex::new(HashMap::new()));

    let mut handles = vec![];

    for i in 0..10 {
        let map = Arc::clone(&map);
        let handle = thread::spawn(move || {
            let mut map = map.lock().unwrap();
            map.insert(i, i * 10); // キーと値を追加
        });
        handles.push(handle);
    }

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

    let final_map = map.lock().unwrap();
    for (key, value) in final_map.iter() {
        println!("Key: {}, Value: {}", key, value);
    }
}

この例では、HashMapに対してスレッドセーフな書き込みを行っています。

まとめ

  • ArcとMutexを組み合わせることで、スレッド間でデータを安全に共有および操作できます。
  • ロックの競合を減らしつつ、データ構造の保護を適切に行うことが並列処理の成功の鍵です。
  • 応用次第でより複雑なデータ処理や構造体の共有も可能になります。

次は、Rustにおけるスレッドセーフ性に関連する課題とその解決策を解説します。

Rustにおけるスレッドセーフの課題と解決策

Rustは強力なスレッドセーフ性を保証しますが、実際の並列プログラムの開発ではいくつかの課題に直面することがあります。ここでは、代表的な課題とその解決策を詳しく解説します。

課題1: ロックの競合によるパフォーマンス低下

MutexやRwLockを使用する場合、スレッド間でロックを競合する可能性があり、パフォーマンスが低下することがあります。

解決策: ロックの粒度を細かくする


ロックの範囲を必要最小限にすることで競合を減らします。以下の例では、計算部分とロック操作を分離しています。

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

fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let increment = 1; // ロック外で計算
            let mut num = counter.lock().unwrap();
            *num += increment;
        });
        handles.push(handle);
    }

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

    println!("Final counter value: {}", *counter.lock().unwrap());
}

計算をロックの外で行うことで、ロック時間を短縮し競合を減らします。

課題2: デッドロックの発生

複数のMutexやRwLockを使用する場合、ロックの順序が原因でデッドロックが発生することがあります。

解決策: ロックの順序を統一する


すべてのスレッドでロックを取得する順序を統一することで、デッドロックを防ぎます。

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

fn main() {
    let resource1 = Arc::new(Mutex::new(0));
    let resource2 = Arc::new(Mutex::new(0));

    let r1 = Arc::clone(&resource1);
    let r2 = Arc::clone(&resource2);
    let handle1 = thread::spawn(move || {
        let _lock1 = r1.lock().unwrap();
        let _lock2 = r2.lock().unwrap();
        println!("Thread 1: Locked both resources");
    });

    let r1 = Arc::clone(&resource1);
    let r2 = Arc::clone(&resource2);
    let handle2 = thread::spawn(move || {
        let _lock1 = r1.lock().unwrap();
        let _lock2 = r2.lock().unwrap();
        println!("Thread 2: Locked both resources");
    });

    handle1.join().unwrap();
    handle2.join().unwrap();
}

このコードでは、両方のスレッドが同じ順序でロックを取得するため、デッドロックが防止されます。

課題3: スレッド間の共有データの過剰な複雑化

複雑なデータ構造を共有する際、ArcやMutexのネストが深くなり、コードの可読性が低下する場合があります。

解決策: データ構造を簡略化する


必要に応じてデータ構造をリファクタリングし、単純化します。また、dashmapなどの専用ライブラリを使用することも検討できます。

use dashmap::DashMap;
use std::sync::Arc;

fn main() {
    let map = Arc::new(DashMap::new());
    let map_clone = Arc::clone(&map);

    let handle = std::thread::spawn(move || {
        map_clone.insert("key", 42);
    });

    handle.join().unwrap();
    println!("Value: {:?}", map.get("key"));
}

DashMapは、並列環境でのスレッドセーフなハッシュマップの実装を提供します。

課題4: ライブロックやスタベーション

特定のスレッドが優先される設計では、他のスレッドが適切に進行できないことがあります（スタベーション）。

解決策: フェアネスを考慮した設計


std::sync::Condvarを使用してフェアネスを保証する仕組みを設計することで、特定のスレッドが進行し続ける問題を回避できます。

まとめ


Rustにおけるスレッドセーフ性の課題は、設計やツールの工夫で解決可能です。

  • ロックの粒度を細かくする。
  • ロックの順序を統一してデッドロックを回避する。
  • データ構造の複雑さを軽減する。
  • スレッド間の公平性を考慮する。

これらを実践することで、効率的かつ安全な並列プログラムの構築が可能になります。次は、これまで解説した内容を総括する「まとめ」をお届けします。

まとめ

本記事では、Rustにおけるスレッドセーフ性を保証するSendとSyncトレイトについて詳しく解説しました。これらのトレイトは、所有権システムと密接に連携し、並列処理におけるデータ競合や未定義動作を防ぎます。

具体的には、以下のポイントを中心に説明しました：

  • SendとSyncトレイトの基本的な役割と適用範囲
  • カスタム型での実装方法と注意点
  • MutexとArcを活用したスレッドセーフなプログラム設計
  • 並列処理における課題（デッドロック、ロック競合など）の解決策

Rustが提供する強力な所有権とトレイトシステムを活用することで、安全かつ効率的な並列プログラムを構築できます。これらの知識を活用し、複雑な並列処理にも自信を持って挑戦してください。

Rust
スレッドセーフ Rust Sendトレイト Syncトレイト

コメント

コメントする

目次