Tokioのベストプラクティス

Tokioを使った非同期プログラミングのベストプラクティス

ベストプラクティス

1. 依存関係の管理
• Cargo.toml で必要な tokio の機能だけを有効にして、ビルド時間やバイナリサイズを削減します。

[dependencies]
tokio = { version = "1", features = ["full"] }

2. 適切なランタイムの選択
• CPUバウンドなタスクが多い場合は multi_thread ランタイム、I/Oバウンドなタスクが多い場合は current_thread ランタイムを選択します。

#[tokio::main(flavor = "multi_thread")]
async fn main() {
    // your code here
}

3. 非同期タスクの適切な使用
• tokio::spawn でタスクを並列実行し、必要に応じて JoinHandle でタスクの結果を待ちます。

let handle = tokio::spawn(async {
    // some async work
});

let result = handle.await.unwrap();

4. タイムアウトの設定
• 長時間かかる操作にはタイムアウトを設定し、ハングアップを防ぎます。

use tokio::time::{timeout, Duration};

let result = timeout(Duration::from_secs(5), async_operation()).await;
match result {
    Ok(Ok(value)) => println!("Success: {:?}", value),
    Ok(Err(e)) => eprintln!("Operation failed: {:?}", e),
    Err(_) => eprintln!("Operation timed out"),
}

5. 非同期I/Oの利用
• 非同期I/O操作には tokio の非同期I/Oクレートを使用し、I/O待ちでスレッドがブロックされないようにします。

use tokio::io::{self, AsyncReadExt};

async fn read_from_file(path: &str) -> io::Result<String> {
    let mut file = tokio::fs::File::open(path).await?;
    let mut contents = String::new();
    file.read_to_string(&mut contents).await?;
    Ok(contents)
}

6. スレッド間通信
• スレッド間通信には tokio::sync のチャネルを使用し、MPSCチャネルやブロッキングチャネルを状況に応じて使い分けます。

use tokio::sync::mpsc;

let (tx, mut rx) = mpsc::channel(8);

tokio::spawn(async move {
    tx.send("message").await.unwrap();
});

while let Some(message) = rx.recv().await {
    println!("Received: {}", message);
}

7. リソースの適切なクリーンアップ
• タスク終了時にリソースを適切にクリーンアップするために、Drop トレイトを実装して自動的にリソースを解放します。

struct MyResource {
    // some resources
}

impl Drop for MyResource {
    fn drop(&mut self) {
        // clean up resources
    }
}

8. エラーハンドリング
• 非同期コードで適切なエラーハンドリングを行い、Result 型を使用してエラーを伝播させます。

async fn my_async_function() -> Result<(), Box<dyn std::error::Error>> {
    // some code
    Ok(())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    my_async_function().await?;
    Ok(())
}

9. 適切なログ出力
• tracing クレートを使用してログを出力し、デバッグや監視を容易にします。

[dependencies]
tracing = "0.1"
tracing-subscriber = "0.2"

use tracing::{info, error};
use tracing_subscriber;

#[tokio::main]
async fn main() {
    tracing_subscriber::fmt::init();
    info!("Starting application");
    if let Err(e) = my_async_function().await {
        error!("Error occurred: {:?}", e);
    }
}

10. ユニットテスト
• 非同期関数のテストには tokio::test アトリビュートを使用します。

#[cfg(test)]
mod tests {
    #[tokio::test]
    async fn test_async_function() {
        let result = my_async_function().await;
        assert!(result.is_ok());
    }
}