MENU
  1. ホーム
  2. Rust
  3. Rustで学ぶ並列処理とメモリリークを防ぐスレッド管理の実践

Rustで学ぶ並列処理とメモリリークを防ぐスレッド管理の実践

Rust

Rustは、その安全性と性能を兼ね備えた特徴により、多くのプログラミング領域で注目を集めています。その中でも並列処理は、効率的なリソース利用とアプリケーション性能の向上を実現するために重要な技術です。しかし、並列処理にはメモリリークや競合などのリスクが伴います。Rustの所有権モデルは、これらの問題を未然に防ぐための強力な武器となります。本記事では、Rustを用いて並列処理を安全かつ効果的に実現する方法を、実例を交えて解説します。スレッド管理の基本から応用的な設計パターン、さらにメモリリーク防止のデバッグ方法までを網羅し、実践的なスキルを身につけることができます。

目次

並列処理におけるメモリリークの概要


並列処理は、コンピュータの複数のコアを活用して処理を高速化するための技術です。しかし、その性質上、メモリ管理に慎重を期さなければメモリリークが発生する可能性があります。メモリリークとは、プログラムが使用しなくなったメモリ領域が解放されず、システムリソースを消耗し続ける現象を指します。

並列処理とメモリリークの関係


並列処理では、複数のスレッドが同時に動作します。これにより以下の問題が発生する可能性があります。

  1. リソースの競合: スレッド間で共有されるメモリリソースが適切に管理されていない場合、メモリが解放されずにリークが発生します。
  2. 参照カウントの循環: スレッド間で循環参照が発生すると、ガベージコレクターがそのメモリを解放できなくなることがあります。
  3. 解放忘れ: 開発者が明示的にメモリを解放する必要がある状況で、その操作が行われない場合、メモリが使われたままになることがあります。

メモリリークが引き起こす問題


メモリリークは、プログラムの動作を徐々に不安定にし、最終的にはクラッシュやパフォーマンス低下を招きます。また、サーバーやリアルタイムシステムなど、長時間稼働するアプリケーションでは致命的な問題となり得ます。

Rustにおけるメモリリーク対策


Rustは、所有権モデルとライフタイム管理によって、メモリリークのリスクを大幅に軽減します。特に、コンパイル時に所有権違反やリソースの二重解放を防ぐ仕組みは、並列処理の安全性を高める上で非常に有効です。本記事では、これらの概念を具体的な実例を通じて詳しく解説します。

Rustが提供する安全な並列処理の特徴


Rustは、他のプログラミング言語に比べて安全性を重視した並列処理を可能にする特性を持っています。この安全性は、主に所有権システムと型システムによって実現されています。これにより、開発者はランタイムエラーや未定義動作を心配することなく並列処理を実装できます。

所有権モデルの利点


Rustの所有権モデルは、メモリの管理を明確にすることで以下の利点を提供します。

  1. メモリ安全性: 変数が一度に1つのスレッドによってのみ所有されるため、他のスレッドによる予期しない変更や破壊が防止されます。
  2. 自動解放: オブジェクトのスコープを抜けると自動的にメモリが解放され、手動で解放する必要がありません。

コンパイル時チェックによるエラー防止


Rustでは、並列処理で発生しがちな以下のようなエラーをコンパイル時に検出できます。

  • データ競合: 複数のスレッドが同時に同じメモリにアクセスしようとする競合。
  • 不正な所有権移動: スレッド間で不適切な所有権の受け渡しが行われる場合。

これにより、開発中に潜在的な問題を修正でき、実行時エラーを防ぐことが可能です。

並列処理のためのRust標準ライブラリ


Rustの標準ライブラリは、安全な並列処理をサポートするために以下のようなツールを提供しています。

  • std::thread: スレッドの生成と管理を行います。
  • std::sync::Mutex: スレッド間での安全なデータ共有を可能にします。
  • std::sync::Arc: 複数のスレッドで安全に共有できるスマートポインタです。
  • std::sync::mpsc: メッセージパッシングを用いてスレッド間通信を行います。

実例からの理解


以下は、Rustの特徴を生かしてスレッド間のデータ競合を防ぐ簡単な例です。

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 mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

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

このコードでは、ArcとMutexを組み合わせてスレッド間で共有されるカウンターを管理しています。Mutexが競合を防ぎ、Arcが所有権を安全に共有しています。

Rustのこれらの機能を活用することで、並列処理を安全かつ効率的に実装できることを次のセクションでさらに掘り下げていきます。

スレッドのライフサイクル管理方法


Rustでは、スレッドの生成から終了までのライフサイクルを明確に管理できます。スレッド管理の基本を理解することで、並列処理を効率的に設計し、予期しないエラーを防ぐことができます。

スレッドの生成


Rustではstd::threadモジュールを使用して簡単にスレッドを生成できます。以下はスレッドを生成する基本的な例です。

use std::thread;

fn main() {
    let handle = thread::spawn(|| {
        println!("スレッド内での処理");
    });

    handle.join().unwrap();
    println!("メインスレッドでの処理");
}

このコードでは、新しいスレッドを生成し、処理を行った後にjoinを使って終了を待機しています。

スレッドの終了


スレッドは、以下の条件で終了します。

  1. 終了条件の達成: スレッド内の処理が完了した場合。
  2. 親スレッドからの強制終了: Rustでは通常、強制終了は非推奨です。スレッドの終了はjoinを用いて明示的に管理します。

スレッドの中断と再開


Rustでは、スレッドを一時中断するためにthread::sleepを使用します。以下は一時中断の例です。

use std::thread;
use std::time::Duration;

fn main() {
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("スレッド内の処理: {}", i);
            thread::sleep(Duration::from_millis(500));
        }
    });

    handle.join().unwrap();
}

この例では、500ミリ秒間隔で処理を行っています。

スレッド管理のベストプラクティス

  1. リソース管理の明確化
    スレッドで使用するリソースはスコープ内で管理し、スレッド終了後に適切に解放します。
  2. 所有権と借用の適切な利用
    Rustの所有権モデルを活用して、スレッド間で共有されるデータの競合を防ぎます。
  3. スレッドの命名と識別
    スレッドのデバッグを容易にするため、スレッドに名前を付けることが有効です。
use std::thread;

fn main() {
    let builder = thread::Builder::new().name("worker_thread".to_string());
    let handle = builder.spawn(|| {
        println!("名前付きスレッドでの処理");
    }).unwrap();

    handle.join().unwrap();
}

スレッドの数の制御


多すぎるスレッドはシステムのパフォーマンスに悪影響を及ぼします。そのため、スレッドプールを利用することでスレッド数を制御できます。この手法は次のセクションで詳しく説明します。

スレッドのライフサイクル管理を理解することで、効率的で安定した並列処理を実現できます。この基礎知識をもとに、さらに高度な並列処理設計を進めていきましょう。

メッセージパッシングによるスレッド間通信


並列処理において、スレッド間のデータ共有は避けて通れない課題です。Rustでは、メッセージパッシングを用いることで、安全かつ効率的にスレッド間通信を実現できます。Rust標準ライブラリが提供するmpsc（multiple producer, single consumer）モジュールを利用することで、複数のスレッドから1つのスレッドへデータを送信する仕組みを構築します。

mpscチャネルの基本


Rustのmpscモジュールを使用してチャネルを作成し、スレッド間でデータを送受信します。以下はその基本的な例です。

use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn main() {
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec!["メッセージ1", "メッセージ2", "メッセージ3"];
        for message in messages {
            tx.send(message).unwrap();
            thread::sleep(Duration::from_millis(500));
        }
    });

    for received in rx {
        println!("受信: {}", received);
    }
}

このコードでは、スレッドが複数のメッセージを送信し、メインスレッドがそれを受信します。

複数のプロデューサ


複数のスレッドからデータを送信する場合、チャネルをクローンして使用します。

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for i in 1..=3 {
        let tx_clone = tx.clone();
        thread::spawn(move || {
            tx_clone.send(format!("スレッド{}からのメッセージ", i)).unwrap();
        });
    }

    drop(tx); // 全ての送信側をクローズ

    for received in rx {
        println!("受信: {}", received);
    }
}

この例では、複数のスレッドが1つのレシーバーにメッセージを送信し、それぞれのスレッドの処理結果が受信されます。

メッセージパッシングの利点

  1. データ競合の回避: メッセージパッシングにより、スレッド間での直接的なデータ共有を避けられるため、データ競合のリスクが低下します。
  2. シンプルな設計: メッセージを送受信する明確な流れがあり、プログラムの構造が分かりやすくなります。
  3. 所有権の移動: メッセージ送信時に所有権が移動するため、データの不正な使用が防止されます。

注意点

  1. パフォーマンスのトレードオフ: メッセージパッシングは、共有メモリに比べてオーバーヘッドが増える場合があります。性能要件に応じて選択してください。
  2. 送信側のクローズ: すべての送信側が終了していない場合、レシーバーがデータを待ち続ける可能性があります。不要なチャネルは早めにクローズすることが重要です。

応用例: ログ収集システム


メッセージパッシングを使用したログ収集システムの例を示します。複数のスレッドが独自のログを生成し、メインスレッドで集約する仕組みです。

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();
    let handles: Vec<_> = (1..=3)
        .map(|i| {
            let tx_clone = tx.clone();
            thread::spawn(move || {
                tx_clone.send(format!("スレッド{}: ログエントリ", i)).unwrap();
            })
        })
        .collect();

    drop(tx);

    for log in rx {
        println!("集約されたログ: {}", log);
    }

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

このコードでは、複数のスレッドがログを生成し、メインスレッドでそれらを収集して出力します。

メッセージパッシングは、データの競合を避けつつ並列処理を安全に実装するための効果的な手法です。次のセクションでは、さらに高度なリソース管理手法について学びます。

MutexとArcを用いた共有リソース管理


並列処理において、複数のスレッドが同じリソースを使用する際にはデータ競合が発生する可能性があります。RustではMutex（ミューテックス）とArc（アトミックリファレンスカウント）を組み合わせることで、安全に共有リソースを管理することが可能です。

Mutexの基本概念


Mutexは、一度に1つのスレッドだけがリソースにアクセスできるようにする仕組みを提供します。lockメソッドを用いてリソースにアクセスする際、他のスレッドはロックが解除されるまで待機します。

以下はMutexの基本的な使用例です。

use std::sync::Mutex;

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

    {
        let mut num = counter.lock().unwrap();
        *num += 1;
    }

    println!("Counter: {:?}", counter);
}

このコードでは、counterをロックして値を変更し、スコープを抜けた時点でロックが自動的に解除されます。

Arcを用いた共有リソースの管理


Arcは、複数のスレッド間で所有権を共有するためのスマートポインタです。ArcとMutexを組み合わせることで、安全にリソースを共有できます。

以下は複数スレッド間で共有カウンターを管理する例です。

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 mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

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

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

このコードでは、Arc::cloneを用いてカウンターの所有権をスレッド間で共有しています。

MutexとArcを使用する際の注意点

  1. デッドロックの回避
    複数のスレッドが複数のリソースをロックしようとする場合、デッドロックが発生する可能性があります。リソースのロック順序を統一することで回避できます。
  2. ロックの時間を最小限に抑える
    長時間ロックを保持すると、他のスレッドが待機状態となり効率が低下します。必要な処理が終わったら速やかにロックを解除しましょう。
  3. エラーハンドリング
    lockメソッドの呼び出し時にエラーが発生する可能性があります。unwrapを用いる場合はエラー時の挙動に注意が必要です。

応用例: 並列計算


以下は、複数のスレッドで配列の要素を並列に計算し、結果を集計する例です。

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

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    let sum = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for chunk in data.chunks(1) {
        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.lock().unwrap();
            *total += partial_sum;
        });

        handles.push(handle);
    }

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

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

このコードでは、Mutexで保護された共有リソースsumに複数のスレッドが安全にアクセスし、並列計算を実現しています。

まとめ


MutexとArcを組み合わせることで、並列処理の安全性を確保しながら効率的にリソースを共有できます。これらの仕組みを正しく活用することで、データ競合やデッドロックを回避しながら高度な並列処理を実現できます。次のセクションでは、さらに効率的なタスク管理を可能にするスレッドプールについて解説します。

実例：スレッドプールの設計と実装


スレッドプールは、複数のスレッドを事前に作成し、それを再利用することでリソースの浪費を防ぎ、並列処理の効率を向上させる仕組みです。Rustでは、スレッドプールを手動で実装することも可能であり、それによって並列処理の挙動をより詳細に制御できます。

スレッドプールの基本構造


スレッドプールは以下の要素から構成されます。

  1. ワーカースレッド: タスクを実行するスレッドの集合。
  2. タスクキュー: 実行待ちのタスクを保持するキュー。
  3. タスク分配機構: キューからタスクを取り出してスレッドに割り当てる仕組み。

スレッドプールの実装例


以下は、シンプルなスレッドプールを実装する例です。

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

pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: mpsc::Sender<Job>,
}

type Job = Box<dyn FnOnce() + Send + 'static>;

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);

        let (sender, receiver) = mpsc::channel();
        let receiver = Arc::new(Mutex::new(receiver));

        let mut workers = Vec::with_capacity(size);
        for id in 0..size {
            workers.push(Worker::new(id, Arc::clone(&receiver)));
        }

        ThreadPool { workers, sender }
    }

    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);
        self.sender.send(job).unwrap();
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        for worker in &mut self.workers {
            println!("Worker {}を終了しています", worker.id);

            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
        let thread = thread::spawn(move || loop {
            let job = receiver.lock().unwrap().recv().unwrap();
            println!("Worker {}がタスクを実行中", id);
            job();
        });

        Worker {
            id,
            thread: Some(thread),
        }
    }
}

使用例


作成したスレッドプールを用いて複数のタスクを実行します。

fn main() {
    let pool = ThreadPool::new(4);

    for i in 0..8 {
        pool.execute(move || {
            println!("タスク {} を実行中", i);
        });
    }
}

このコードでは、4つのワーカースレッドを持つスレッドプールが作成され、8つのタスクが効率的に実行されます。

スレッドプールを利用する利点

  1. スレッド生成のコスト削減
    タスクごとに新しいスレッドを生成するコストを削減できます。
  2. スケーラビリティ
    スレッド数を事前に決定することで、過剰なスレッド生成によるシステムの負荷を防ぎます。
  3. タスクの効率的な分配
    タスクキューにより、スレッドに均等にタスクを割り当てることができます。

注意点

  1. デッドロックの防止
    スレッドがロックを解除しない場合、タスクがスタックしてスレッドプール全体が停止する可能性があります。
  2. タスクの適切な終了管理
    プログラム終了時に全てのタスクを完了させるため、スレッドプールのライフサイクルを適切に管理する必要があります。

スレッドプールの実装を理解し、応用することで、効率的でスケーラブルな並列処理をRustで実現する基盤を構築できます。次のセクションでは、メモリリークのデバッグとトラブルシューティングについて解説します。

メモリリークのデバッグとトラブルシューティング


並列処理を実装する際、メモリリークの検出と解消は、アプリケーションの安定性を保つために不可欠です。Rustでは、所有権モデルによってメモリリークが発生しにくい設計になっていますが、開発中の不注意や特定のケースでは発生する可能性があります。本セクションでは、メモリリークの原因を特定し、解消するためのデバッグ手法を解説します。

Rustでメモリリークが発生するケース

  1. 循環参照
    RcやArcを利用する際、オブジェクト間で循環参照が発生するとメモリが解放されません。
  2. 未処理のタスク
    スレッドプールや非同期タスクの中で、終了していないタスクがリソースを保持し続ける場合があります。
  3. アンセーフコード
    unsafeブロックで適切にメモリを解放しない場合、メモリリークが発生する可能性があります。

メモリリークの検出手法

  1. デバッグツールの使用
    Rustには、メモリリークやバグを検出するためのツールがいくつか存在します。
  • Valgrind: 実行時にメモリリークを検出します。
  • Heaptrack: メモリ使用量を追跡し、どの部分がメモリを占有しているかを特定します。
  1. std::memモジュールの活用
    Rustの標準ライブラリにはメモリ情報を追跡するモジュールがあります。
  2. コンパイラ警告の確認
    cargo checkやcargo clippyを使用して、所有権や参照の問題を特定します。

循環参照の解消方法


循環参照を解消するには、Weak参照を利用します。以下はその例です。

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

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

fn main() {
    let parent = Rc::new(Node {
        value: 1,
        parent: RefCell::new(Weak::new()),
        children: RefCell::new(vec![]),
    });

    let child = Rc::new(Node {
        value: 2,
        parent: RefCell::new(Rc::downgrade(&parent)),
        children: RefCell::new(vec![]),
    });

    parent.children.borrow_mut().push(child);

    println!("親の参照カウント: {}", Rc::strong_count(&parent));
}

このコードでは、Weakを使って循環参照を回避しています。

デバッグの実践例


以下のコードは、メモリリークが発生する可能性を意図的に含んでいます。

use std::rc::Rc;

fn main() {
    let a = Rc::new(vec![1, 2, 3]);
    let b = Rc::clone(&a);

    println!("aの参照カウント: {}", Rc::strong_count(&a));

    // ここでaとbが循環参照を形成している可能性を調査
}

Valgrindを使用して検出する方法:

  1. プログラムをデバッグビルドでコンパイルします。
   cargo build --debug
  1. Valgrindを実行します。
   valgrind ./target/debug/your_program

トラブルシューティングのステップ

  1. メモリリーク箇所の特定
    ツールやログを活用して、リークの発生箇所を明確にします。
  2. 問題の再現
    問題が再現できる最小限のコードを作成します。
  3. コードの修正
    循環参照を解消し、タスクが正しく終了していることを確認します。
  4. テストの実行
    修正後にテストを実行して問題が解消されたことを確認します。

まとめ


Rustでは、所有権モデルと型システムによりメモリ管理が非常に安全に設計されていますが、循環参照や未処理タスクなどによるメモリリークが発生する可能性は残っています。デバッグツールの活用と適切な設計により、これらの問題を早期に発見し解決することが可能です。次のセクションでは、演習問題を通じて学んだ内容を実践する機会を提供します。

演習問題：並列処理を用いた簡易Webクローラーの作成


この演習では、Rustの並列処理機能を利用して、簡易Webクローラーを作成します。この課題を通じて、スレッド管理、メモリ管理、安全なリソース共有の実践的な知識を深めます。

目標

  • 並列処理で複数のURLを効率的に取得する。
  • ArcとMutexを使用して、結果を安全に共有する。
  • メモリリークやデッドロックを防ぐ設計を学ぶ。

課題の仕様

  1. 与えられた複数のURLに並列でリクエストを送信する。
  2. レスポンスのステータスコードと内容の一部を記録する。
  3. スレッド間でリソース（結果リスト）を安全に共有する。

実装例

以下に簡易Webクローラーのコード例を示します。

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

fn main() {
    let urls = vec![
        "https://www.rust-lang.org",
        "https://www.google.com",
        "https://www.github.com",
    ];

    let results = Arc::new(Mutex::new(Vec::new()));
    let mut handles = vec![];

    for url in urls {
        let results = Arc::clone(&results);
        let url = url.to_string();

        let handle = thread::spawn(move || {
            let response = reqwest::blocking::get(&url);

            let result = match response {
                Ok(resp) => {
                    let status = resp.status();
                    let body = resp.text().unwrap_or_else(|_| "取得失敗".to_string());
                    (url, status.to_string(), body.chars().take(50).collect::<String>())
                }
                Err(_) => (url, "エラー".to_string(), "取得失敗".to_string()),
            };

            let mut results_lock = results.lock().unwrap();
            results_lock.push(result);
        });

        handles.push(handle);
    }

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

    let results_lock = results.lock().unwrap();
    for (url, status, snippet) in results_lock.iter() {
        println!("URL: {}\nステータス: {}\n内容: {}\n", url, status, snippet);
    }
}

コードの説明

  1. リソースの共有
    resultsはArc<Mutex<Vec<_>>>として定義され、スレッド間で安全に共有されます。
  2. スレッドの生成
    各URLに対してスレッドを生成し、並列でリクエストを送信します。
  3. レスポンスの処理
    成功した場合はステータスコードと内容を取得し、失敗した場合はエラーメッセージを記録します。
  4. 結果の収集
    各スレッドから収集された結果をresultsに格納し、最後に出力します。

演習課題

  1. エラー処理の強化
    ネットワークエラーやタイムアウトをより詳細にログに記録してください。
  2. スレッドプールの導入
    自前でスレッドプールを実装して、スレッド数を制御してみましょう。
  3. 並列度の計測
    実行時間を計測し、並列処理がどの程度効率化されているか確認してください。

実行結果の例

URL: https://www.rust-lang.org
ステータス: 200 OK
内容: Rustプログラミング言語 - ホームページ

URL: https://www.google.com
ステータス: 200 OK
内容: Google - 世界中の情報を整理して、誰もがアクセス

URL: https://www.github.com
ステータス: 200 OK
内容: GitHub: Where the world builds software · GitHub

学びのポイント

  1. 並列処理でリソースを安全に共有する方法。
  2. メモリ管理とスレッド管理のベストプラクティス。
  3. 実用的な並列処理の設計と実装。

この演習を通じて、Rustで並列処理を実践するスキルを磨くことができます。次のセクションでは、学んだ内容を振り返りつつ、記事全体をまとめます。

まとめ


本記事では、Rustを用いた並列処理の基本から応用までを解説しました。メモリリークのリスクを理解し、Rustの所有権モデルやスレッド管理、ArcとMutexの活用方法を学ぶことで、安全で効率的な並列処理を実現するスキルを習得できました。

また、スレッドプールの設計や演習を通じて、実用的な並列処理の設計力を高める方法にも触れました。Rustの強力なツールと安全な設計により、複雑な並列処理も簡潔に実装できます。これらの知識を活かして、実際のプロジェクトで安定性と性能を両立するコードを書いていきましょう。

Rust
並列処理 Rust メモリリーク防止

コメント

コメントする

目次