Rustでasync fnをFutureへ変換する仕組みと自前Executor実装ガイド

Contents

1 async fn がコンパイル時に生成する状態機械
- 1.1 何が起きているか
- 1.2 cargo expand で見えるコード例
2 基本的な async 関数と .await の使い方
3 Future トレイトを手動で実装するポイント
4 最小限の executor を作る
5 カスタムランタイムと既存ライブラリの比較・実務での選択基準
- 5.1 どちらを選ぶべきか？
6 典型的なコンパイルエラーと対処法
- 6.1 実践的な対処フロー
7 デバッグ・ベンチマーク手法
8 次のステップ

スポンサードリンク

`async fn` がコンパイル時に生成する状態機械

何が起きているか

async fn は 呼び出し時に 実行されるコードではなく、コンパイル時に 以下の2つを自動で作ります。

匿名構造体 – 関数本体で使われるローカル変数や中間結果をフィールドとして保持。
Future の実装 – その構造体が Future トレイトを実装し、poll メソッドの中で .await が 「現在の状態から次の状態へ遷移する」 ロジックに変換される。

参考: Rust Async Book – https://doc.rust-lang.org/book/ch20-02-multithreaded.html

`cargo expand` で見えるコード例

// async fn の元になるコード
async fn fetch() -&gt; u32 {
    let a = async_op1().await;
    let b = async_op2(a).await;
    b + 1
}

// async fn の元になるコード

async fn fetch() -> u32 {

let a = async_op1().await;

let b = async_op2(a).await;

b + 1

}

cargo expand（公式ツール）で得られる概形は次の通りです。

use std::pin::Pin;
use std::task::{Context, Poll};

struct Fetch&lt;'a&gt; {
    state: u8,
    a: Option&lt;u32&gt;,
    // 省略された内部フィールド …
}

impl&lt;'a&gt; Future for Fetch&lt;'a&gt; {
    type Output = u32;

    fn poll(self: Pin&lt;&amp;mut Self&gt;, cx: &amp;mut Context&lt;'_&gt;) -&gt; Poll&lt;Self::Output&gt; {
        // `self` は Pin されているので安全に参照できる
        let this = unsafe { self.get_unchecked_mut() };
        loop {
            match this.state {
                0 =&gt; {
                    // async_op1 のポーリング
                    match async_op1().poll(cx) {
                        Poll::Ready(v) =&gt; {
                            this.a = Some(v);
                            this.state = 1;
                        }
                        Poll::Pending =&gt; return Poll::Pending,
                    }
                }
                1 =&gt; {
                    let a = this.a.unwrap();
                    match async_op2(a).poll(cx) {
                        Poll::Ready(v) =&gt; return Poll::Ready(v + 1),
                        Poll::Pending =&gt; return Poll::Pending,
                    }
                }
                _ =&gt; unreachable!(),
            }
        }
    }
}

use std::pin::Pin;

use std::task::{Context, Poll};

struct Fetch<'a> {

state: u8,

a: Option<u32>,

// 省略された内部フィールド …

}

impl<'a> Future for Fetch<'a> {

type Output = u32;

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

// `self` は Pin されているので安全に参照できる

let this = unsafe { self.get_unchecked_mut() };

loop {

match this.state {

0 => {

// async_op1 のポーリング

match async_op1().poll(cx) {

Poll::Ready(v) => {

this.a = Some(v);

this.state = 1;

}

Poll::Pending => return Poll::Pending,

}

1 => {

let a = this.a.unwrap();

match async_op2(a).poll(cx) {

Poll::Ready(v) => return Poll::Ready(v + 1),

Poll::Pending => return Poll::Pending,

}

_ => unreachable!(),

}

state が現在の制御フローを示す。
各 await は内部で別々の Future の poll を呼び出し、Pending になった時点で外側の poll も Pending を返す。

この変換があるおかげで、ユーザーは 「.await」 と書くだけで非同期制御フローを記述できる。

基本的な async 関数と `.await` の使い方

use std::time::Duration;
use async_std::task; // 例として async‑std のブロックオン

async fn hello() -&gt; &amp;'static str {
    task::sleep(Duration::from_secs(1)).await;
    &quot;Hello, async!&quot;
}

fn main() {
    let msg = task::block_on(hello());
    println!(&quot;{}&quot;, msg); // =&gt; Hello, async!
}

use std::time::Duration;

use async_std::task; // 例として async‑std のブロックオン

async fn hello() -> &'static str {

task::sleep(Duration::from_secs(1)).await;

"Hello, async!"

}

fn main() {

let msg = task::block_on(hello());

println!("{}", msg); // => Hello, async!

}

task::sleep は 非同期タイマー で、内部的に OS のタイマーやイベントループを利用してブロックしない。
.await が現れるたびにコンパイラ生成コードの poll が呼ばれ、タイマーが完了すると再開される。

公式ドキュメント: https://doc.rust-lang.org/std/future/trait.Future.html

`Future` トレイトを手動で実装するポイント

3‑1️⃣ `poll` と `Pin`／`Unpin` の意味

用語	説明
`Pin<&mut T>`	`T` がメモリ上で移動しないことを保証。自己参照構造体（例: 内部に `&self` を保持する）を安全に扱える。
`Unpin`	デフォルトではすべての型は `Unpin` だが、`#[pin_project]` 等で「ピン留めできない」構造体を作ることも可能。`Future::poll` の引数は `Pin<&mut Self>` なので、`Unpin` が必要なときは `Box::pin` や `Pin::new_unchecked` を使う。
安全にピン留めする方法	手動で `Pin::new(&mut value)`（スタック上） `Box::pin(value)`（ヒープ） `#[pin_project]` クレートで自動生成された `project()` メソッドを利用

ピン留めの実例（`pin_project` 使用）

# Cargo.toml
pin-project = &quot;1.1&quot;

# Cargo.toml

pin-project = "1.1"

use pin_project::pin_project;
use std::{future::Future, pin::Pin, task::{Context, Poll}};

#[pin_project]
struct MyFuture {
    #[pin] inner: async_std::task::Sleep,
}

impl Future for MyFuture {
    type Output = ();

    fn poll(self: Pin&lt;&amp;mut Self&gt;, cx: &amp;mut Context&lt;'_&gt;) -&gt; Poll&lt;Self::Output&gt; {
        // `self.project()` が安全にピン化されたフィールドへの可変参照を返す
        let this = self.project();
        this.inner.poll(cx)
    }
}

use pin_project::pin_project;

use std::{future::Future, pin::Pin, task::{Context, Poll}};

#[pin_project]

struct MyFuture {

#[pin] inner: async_std::task::Sleep,

}

impl Future for MyFuture {

type Output = ();

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

// `self.project()` が安全にピン化されたフィールドへの可変参照を返す

let this = self.project();

this.inner.poll(cx)

}

3‑2️⃣ カウンタ Future の実装例

use std::{
    future::Future,
    pin::Pin,
    task::{Context, Poll},
};

pub struct SimpleCounter {
    count: u8,
}

impl SimpleCounter {
    pub fn new() -&gt; Self { Self { count: 0 } }
}

impl Future for SimpleCounter {
    type Output = u8;

    fn poll(mut self: Pin&lt;&amp;mut Self&gt;, _cx: &amp;mut Context&lt;'_&gt;) -&gt; Poll&lt;Self::Output&gt; {
        if self.count &lt; 10 {
            self.count += 1;
            // 実際の非同期処理では `Waker` に通知させるが、デモなのですぐに Pending
            Poll::Pending
        } else {
            Poll::Ready(self.count)
        }
    }
}

use std::{

future::Future,

pin::Pin,

task::{Context, Poll},

};

pub struct SimpleCounter {

count: u8,

}

impl SimpleCounter {

pub fn new() -> Self { Self { count: 0 } }

}

impl Future for SimpleCounter {

type Output = u8;

fn poll(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {

if self.count < 10 {

self.count += 1;

// 実際の非同期処理では `Waker` に通知させるが、デモなのですぐに Pending

Poll::Pending

} else {

Poll::Ready(self.count)

}

ポイント: self は Pin<&mut Self> で受け取っているが、この構造体は自己参照を持たないので Unpin でも問題なし。
実際に使うときは futures::executor::block_on(SimpleCounter::new()) のように Pin::new が自動的に行われる。

3‑3️⃣ 正しいタイマー Future（ブロッキングしない実装）

以下の例では スレッドを生成してブロック する代わりに、std::thread::spawn で 非同期 に Waker を呼び出すだけです。ランタイム外でも安全に利用でき、ブロッキング操作は一切行いません。

use std::{
    future::Future,
    pin::Pin,
    task::{Context, Poll, Waker},
    time::{Duration, Instant},
    sync::{Arc, Mutex},
};

/// `SimpleTimer` は指定した時間が経過したら `Ready(())` を返す Future。
pub struct SimpleTimer {
    deadline: Instant,
    /// まだ完了していないときに保持する（共有）Waker
    shared_waker: Arc&lt;Mutex&lt;Option&lt;Waker&gt;&gt;&gt;,
}

impl SimpleTimer {
    pub fn after(dur: Duration) -&gt; Self {
        let deadline = Instant::now() + dur;
        let timer = SimpleTimer {
            deadline,
            shared_waker: Arc::new(Mutex::new(None)),
        };

        // タイマーが満了したら Waker を呼び出すスレッドを起動
        let waker_clone = Arc::clone(&amp;timer.shared_waker);
        std::thread::spawn(move || {
            let now = Instant::now();
            if deadline &gt; now {
                std::thread::sleep(deadline - now);
            }
            // Waker が登録されていれば呼び出す
            if let Some(w) = waker_clone.lock().unwrap().take() {
                w.wake();
            }
        });

        timer
    }
}

impl Future for SimpleTimer {
    type Output = ();

    fn poll(self: Pin&lt;&amp;mut Self&gt;, cx: &amp;mut Context&lt;'_&gt;) -&gt; Poll&lt;Self::Output&gt; {
        if Instant::now() &gt;= self.deadline {
            // 時間経過 → 完了
            Poll::Ready(())
        } else {
            // まだ時間が来ていないので、現在の Waker を保存して次回呼び出しに備える
            let mut guard = self.shared_waker.lock().unwrap();
            *guard = Some(cx.waker().clone());
            Poll::Pending
        }
    }
}

use std::{

future::Future,

pin::Pin,

task::{Context, Poll, Waker},

time::{Duration, Instant},

sync::{Arc, Mutex},

};

/// `SimpleTimer` は指定した時間が経過したら `Ready(())` を返す Future。

pub struct SimpleTimer {

deadline: Instant,

/// まだ完了していないときに保持する（共有）Waker

shared_waker: Arc<Mutex<Option<Waker>>>,

}

impl SimpleTimer {

pub fn after(dur: Duration) -> Self {

let deadline = Instant::now() + dur;

let timer = SimpleTimer {

deadline,

shared_waker: Arc::new(Mutex::new(None)),

};

// タイマーが満了したら Waker を呼び出すスレッドを起動

let waker_clone = Arc::clone(&timer.shared_waker);

std::thread::spawn(move || {

let now = Instant::now();

if deadline > now {

std::thread::sleep(deadline - now);

}

// Waker が登録されていれば呼び出す

if let Some(w) = waker_clone.lock().unwrap().take() {

w.wake();

}

});

timer

}

impl Future for SimpleTimer {

type Output = ();

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {

if Instant::now() >= self.deadline {

// 時間経過 → 完了

Poll::Ready(())

} else {

// まだ時間が来ていないので、現在の Waker を保存して次回呼び出しに備える

let mut guard = self.shared_waker.lock().unwrap();

*guard = Some(cx.waker().clone());

Poll::Pending

}

安全性: std::thread::sleep は別スレッドで実行され、ランタイムのスレッドをブロックしない。
注意点: 実際のプロダクションコードでは tokio::time::Sleep や async‑std::task::sleep のように 非同期 I/O タイマー を利用する方がオーバーヘッドが低く、スレッド数を増やす必要がない。

公式ドキュメント: https://doc.rust-lang.org/std/future/trait.Future.html#method.poll

最小限の executor を作る

4‑1️⃣ `RawWaker` と安全な `Waker` の構築例

RawWaker は 低レベル API で、正しく実装しないと未定義動作になる。以下は所有権を Arc に委ねた完全版です。

use std::{
    sync::Arc,
    task::{RawWaker, RawWakerVTable, Waker},
};

/// `WakerData` は `wake` が呼ばれたときに実行したい処理（ここではキューへの再投入）を保持。
struct WakerData {
    // 例: タスクキューへのハンドル
    enqueue: Box&lt;dyn Fn() + Send + Sync&gt;,
}

fn raw_waker_clone(data: *const ()) -&gt; RawWaker {
    // Arc の参照カウントを増やすだけで OK
    let arc = unsafe { Arc::&lt;WakerData&gt;::from_raw(data as *const WakerData) };
    std::mem::forget(arc.clone()); // 増えた分を保持
    RawWaker::new(data, &amp;VTABLE)
}

fn raw_waker_wake(data: *const ()) {
    let arc = unsafe { Arc::&lt;WakerData&gt;::from_raw(data as *const WakerData) };
    (arc.enqueue)(); // キューにタスクを入れる等の実装
    // `wake` 後は所有権が移動したので drop が走る
}

fn raw_waker_wake_by_ref(data: *const ()) {
    let arc = unsafe { Arc::&lt;WakerData&gt;::from_raw(data as *const WakerData) };
    (arc.enqueue)();
    std::mem::forget(arc); // 参照カウントを減らさない
}

fn raw_waker_drop(data: *const ()) {
    // `Arc` のドロップで参照カウントがデクリメントされるだけ
    unsafe { Arc::&lt;WakerData&gt;::from_raw(data as *const WakerData) };
}

// VTABLE は 4 つの関数ポインタを保持するだけ
static VTABLE: RawWakerVTable = RawWakerVTable::new(
    raw_waker_clone,
    raw_waker_wake,
    raw_waker_wake_by_ref,
    raw_waker_drop,
);

/// 任意の `enqueue` クロージャから安全な `Waker` を作るユーティリティ
fn make_waker&lt;F&gt;(enqueue: F) -&gt; Waker
where
    F: Fn() + Send + Sync + 'static,
{
    let data = Arc::new(WakerData {
        enqueue: Box::new(enqueue),
    });
    let raw = RawWaker::new(Arc::into_raw(data) as *const (), &amp;VTABLE);
    unsafe { Waker::from_raw(raw) }
}

use std::{

sync::Arc,

task::{RawWaker, RawWakerVTable, Waker},

};

/// `WakerData` は `wake` が呼ばれたときに実行したい処理（ここではキューへの再投入）を保持。

struct WakerData {

// 例: タスクキューへのハンドル

enqueue: Box<dyn Fn() + Send + Sync>,

}

fn raw_waker_clone(data: *const ()) -> RawWaker {

// Arc の参照カウントを増やすだけで OK

let arc = unsafe { Arc::<WakerData>::from_raw(data as *const WakerData) };

std::mem::forget(arc.clone()); // 増えた分を保持

RawWaker::new(data, &VTABLE)

}

fn raw_waker_wake(data: *const ()) {

let arc = unsafe { Arc::<WakerData>::from_raw(data as *const WakerData) };

(arc.enqueue)(); // キューにタスクを入れる等の実装

// `wake` 後は所有権が移動したので drop が走る

}

fn raw_waker_wake_by_ref(data: *const ()) {

let arc = unsafe { Arc::<WakerData>::from_raw(data as *const WakerData) };

(arc.enqueue)();

std::mem::forget(arc); // 参照カウントを減らさない

}

fn raw_waker_drop(data: *const ()) {

// `Arc` のドロップで参照カウントがデクリメントされるだけ

unsafe { Arc::<WakerData>::from_raw(data as *const WakerData) };

}

// VTABLE は 4 つの関数ポインタを保持するだけ

static VTABLE: RawWakerVTable = RawWakerVTable::new(

raw_waker_clone,

raw_waker_wake,

raw_waker_wake_by_ref,

raw_waker_drop,

);

/// 任意の `enqueue` クロージャから安全な `Waker` を作るユーティリティ

fn make_waker<F>(enqueue: F) -> Waker

where

F: Fn() + Send + Sync + 'static,

{

let data = Arc::new(WakerData {

enqueue: Box::new(enqueue),

});

let raw = RawWaker::new(Arc::into_raw(data) as *const (), &VTABLE);

unsafe { Waker::from_raw(raw) }

}

clone は Arc の参照カウントを増やすだけ。
wake / wake_by_ref では保存したクロージャを呼び出し、タスクキューへの再投入等の実装を行う。
drop は単に Arc を復元してスコープを抜けさせるだけで、参照カウントが減少する。

4‑2️⃣ `futures::task::ArcWake` とシングルスレッドキュー

futures クレートが提供する ArcWake は上記ロジックを簡潔に書くヘルパーです。以下は ミニ executor の核心部分です。

# Cargo.toml
[dependencies]
futures = &quot;0.3&quot;
lazy_static = &quot;1.4&quot;

# Cargo.toml

[dependencies]

futures = "0.3"

lazy_static = "1.4"

use futures::task::{ArcWake, waker_ref};
use std::{
    collections::VecDeque,
    future::Future,
    pin::Pin,
    sync::{Arc, Mutex},
    task::{Context, Poll},
};

/// タスクは `Future` を保持し、`ArcWake` により自ら再スケジュールできる。
struct Task {
    // `Box&lt;dyn Future&gt;` で多態的に保持
    future: Mutex&lt;Option&lt;Box&lt;dyn Future&lt;Output = ()&gt; + Send&gt;&gt;&gt;,
}

impl ArcWake for Task {
    fn wake_by_ref(arc_self: &amp;Arc&lt;Self&gt;) {
        // キューへ再投入（シングルスレッドなのでロックだけで安全）
        let mut queue = GLOBAL_QUEUE.lock().unwrap();
        queue.push_back(arc_self.clone());
    }
}

// グローバルなタスクキュー
lazy_static::lazy_static! {
    static ref GLOBAL_QUEUE: Mutex&lt;VecDeque&lt;Arc&lt;Task&gt;&gt;&gt; = Mutex::new(VecDeque::new());
}

/// `spawn` 相当のユーティリティ
fn spawn&lt;F&gt;(fut: F)
where
    F: Future&lt;Output = ()&gt; + Send + 'static,
{
    let task = Arc::new(Task {
        future: Mutex::new(Some(Box::new(fut))),
    });
    GLOBAL_QUEUE.lock().unwrap().push_back(task);
}

use futures::task::{ArcWake, waker_ref};

use std::{

collections::VecDeque,

future::Future,

pin::Pin,

sync::{Arc, Mutex},

task::{Context, Poll},

};

/// タスクは `Future` を保持し、`ArcWake` により自ら再スケジュールできる。

struct Task {

// `Box<dyn Future>` で多態的に保持

future: Mutex<Option<Box<dyn Future<Output = ()> + Send>>>,

}

impl ArcWake for Task {

fn wake_by_ref(arc_self: &Arc<Self>) {

// キューへ再投入（シングルスレッドなのでロックだけで安全）

let mut queue = GLOBAL_QUEUE.lock().unwrap();

queue.push_back(arc_self.clone());

}

// グローバルなタスクキュー

lazy_static::lazy_static! {

static ref GLOBAL_QUEUE: Mutex<VecDeque<Arc<Task>>> = Mutex::new(VecDeque::new());

}

/// `spawn` 相当のユーティリティ

fn spawn<F>(fut: F)

where

F: Future<Output = ()> + Send + 'static,

{

let task = Arc::new(Task {

future: Mutex::new(Some(Box::new(fut))),

});

GLOBAL_QUEUE.lock().unwrap().push_back(task);

}

4‑3️⃣ 実行ループ（シングルスレッド）

fn run_executor() {
    while let Some(task) = GLOBAL_QUEUE.lock().unwrap().pop_front() {
        // `ArcWake` が実装されたタスクから Waker を生成
        let waker = waker_ref(&amp;task);
        let mut ctx = Context::from_waker(&amp;*waker);

        // Future の取り出しと poll
        let mut future_slot = task.future.lock().unwrap();
        if let Some(mut fut) = future_slot.take() {
            match Pin::new(&amp;mut *fut).poll(&amp;mut ctx) {
                Poll::Ready(_) =&gt; {
                    // 完了 → 何もしない（ドロップで解放される）
                }
                Poll::Pending =&gt; {
                    // 再度キューへ入れる。`wake_by_ref` が呼ばれたら自動で再投入される
                    *future_slot = Some(fut);
                }
            }
        }
    }
}

fn run_executor() {

while let Some(task) = GLOBAL_QUEUE.lock().unwrap().pop_front() {

// `ArcWake` が実装されたタスクから Waker を生成

let waker = waker_ref(&task);

let mut ctx = Context::from_waker(&*waker);

// Future の取り出しと poll

let mut future_slot = task.future.lock().unwrap();

if let Some(mut fut) = future_slot.take() {

match Pin::new(&mut *fut).poll(&mut ctx) {

Poll::Ready(_) => {

// 完了 → 何もしない（ドロップで解放される）

}

Poll::Pending => {

// 再度キューへ入れる。`wake_by_ref` が呼ばれたら自動で再投入される

*future_slot = Some(fut);

}

ポイント
- Waker が呼び出された瞬間に同スレッド上で poll が再度実行できるようになる。
- 本コードは シングルスレッド 向けなので、Mutex だけで競合を防げます。マルチスレッド化する場合は Arc<Mutex<_>> の代わりに crossbeam::queue::SegQueue 等を検討してください。

カスタムランタイムと既存ライブラリの比較・実務での選択基準

項目	Tokio (公式)	async‑std (公式)	本記事のミニ executor
スレッドモデル	ワーカープール（デフォルト＝CPU 数）	シングルスレッドまたは `task::block_on`	手動実装（シングル or カスタム）
I/O サポート	完全非同期 TCP/UDP/ファイル、TLS 等多数	同様に非同期 I/O が標準装備	外部クレート (mio, tokio‑io) を自前で組み合わせる必要あり
エコシステム	`#[tokio::main]` マクロ、豊富なプラグイン	標準ライブラリに近い API	学習・プロトタイプ向き
オーバーヘッド	高め（スケジューラ最適化が多い）	中程度	最小限実装なら極低（ただし機能は限定的）
推奨シーン	大規模サーバ、マルチコア活用が必須	CLI ツール、軽量サービス	ランタイム内部で独自スケジューリングが必要なライブラリ開発や教育目的

どちらを選ぶべきか？

条件	推奨
高スループット・マルチコアが必須	Tokio
依存を極力減らしたい、シンプルさ重視	async‑std
ランタイムの内部構造を自分で制御したい、または学習目的	本ミニ executor

公式情報: https://tokio.rs/ , https://docs.rs/async-std/latest/async_std/

典型的なコンパイルエラーと対処法

エラーメッセージ例	原因	修正例
`future cannot be sent between threads safely`	`Future` が `Send` を実装していない（スレッド間で共有）	すべての内部型を `Arc<Mutex<_>> + Send` に置き換える。例: `Box::pin(async move { … })`
`cannot move out of captured outer variable in an async block`	所有権を `async` ブロック内で移動しようとした	変数を `Arc::clone(&var)` して共有、または `move` キーワードを外す
`the trait bound 'MyFuture: Unpin' is not satisfied`	`Pin<&mut Self>` が必要なのに `Unpin` がない	`Box::pin(my_future)` でピン留め、もしくは `#[pin_project]` を使う

実践的な対処フロー

エラーメッセージを読む → 必要なトレイト (Send, Sync, Unpin) が足りないことが多い。
型の所有権・共有方法を見直す → Arc/Mutex の組み合わせでスレッド安全にする。
ピン留めが必要か判定 → 自己参照構造体なら必ず Pin が必要。pin_project を導入すると安全にフィールドごとに #[pin] を付与できる。

デバッグ・ベンチマーク手法

1. `cargo expand`

cargo install cargo-expand   # 初回だけ
cargo expand --lib          # 生成された状態機械を確認

cargo install cargo-expand # 初回だけ

cargo expand --lib # 生成された状態機械を確認

目的: async fn がどのような構造体・poll に変換されたかを可視化。

2. `tokio::task::yield_now` / `async_std::task::yield_now`

use async_std::task;

async fn step() {
    println!(&quot;before yield&quot;);
    task::yield_now().await;
    println!(&quot;after yield&quot;);
}

use async_std::task;

async fn step() {

println!("before yield");

task::yield_now().await;

println!("after yield");

}

活用例: 手動でスケジューラの切り替えタイミングを観測し、デッドロックやスタックオーバーフローを防止。

3. `criterion` でベンチマーク

# Cargo.toml
[dev-dependencies]
criterion = &quot;0.5&quot;

# Cargo.toml

[dev-dependencies]

criterion = "0.5"

use criterion::{criterion_group, criterion_main, Criterion};
use futures::executor::block_on;

fn bench_simple_counter(c: &amp;mut Criterion) {
    c.bench_function(&quot;simple_counter&quot;, |b| {
        b.iter(|| block_on(SimpleCounter::new()))
    });
}

criterion_group!(benches, bench_simple_counter);
criterion_main!(benches);

use criterion::{criterion_group, criterion_main, Criterion};

use futures::executor::block_on;

fn bench_simple_counter(c: &mut Criterion) {

c.bench_function("simple_counter", |b| {

b.iter(|| block_on(SimpleCounter::new()))

});

}

criterion_group!(benches, bench_simple_counter);

criterion_main!(benches);

比較対象: SimpleCounter（自前実装） vs. tokio::time::sleep 等。
結果の活用: どちらがレイテンシ/スループットに優れるかを数値で示す。

4. ロギングとトレーシング

クレート	用途
`tracing`	非同期タスクの開始・終了を階層的に可視化。
`env_logger`	手軽なログ出力（`RUST_LOG=debug cargo run`）。

use tracing::{info, instrument};

#[instrument]
async fn do_work() {
    info!(&quot;work started&quot;);
    // …
}

use tracing::{info, instrument};

#[instrument]

async fn do_work() {

info!("work started");

// …

}

次のステップ

コードをローカルにコピー → cargo new async_demo && cd async_demo
必要な依存 (futures, lazy_static, pin-project) を Cargo.toml に追記。
cargo run でミニ executor がタスクを正しくスケジュールできるか確認。
完成したら GitHub にリポジトリを作り、README に本記事へのリンクと実行手順を書いて公開。
定期的に 公式ドキュメント（Rust Async Book、Tokio Docs）やクレートの CHANGELOG をチェックし、最新機能やベストプラクティスを取り入れる。

公式情報まとめ
- Rust async/await: https://doc.rust-lang.org/std/future/
- Tokio: https://tokio.rs/tokio/tutorial
- futures crate: https://docs.rs/futures/latest/futures/

この記事は、冗長な「Point (再提示)」を削除し、実装例の正確性と安全性に重点を置いた構成になっています。読者が自分で非同期コードを書き、必要に応じてカスタムランタイムまで作れるようになることを目指しています。

スポンサードリンク

Rustでasync fnをFutureへ変換する仕組みと自前Executor実装ガイド

async fn がコンパイル時に生成する状態機械

何が起きているか

cargo expand で見えるコード例

基本的な async 関数と .await の使い方

Future トレイトを手動で実装するポイント

3‑1️⃣ poll と Pin／Unpin の意味

ピン留めの実例（pin_project 使用）

3‑2️⃣ カウンタ Future の実装例

3‑3️⃣ 正しいタイマー Future（ブロッキングしない実装）

最小限の executor を作る

4‑1️⃣ RawWaker と安全な Waker の構築例

4‑2️⃣ futures::task::ArcWake とシングルスレッドキュー

4‑3️⃣ 実行ループ（シングルスレッド）

カスタムランタイムと既存ライブラリの比較・実務での選択基準

どちらを選ぶべきか？

典型的なコンパイルエラーと対処法

実践的な対処フロー

デバッグ・ベンチマーク手法

1. cargo expand

2. tokio::task::yield_now / async_std::task::yield_now

3. criterion でベンチマーク

4. ロギングとトレーシング

次のステップ

`async fn` がコンパイル時に生成する状態機械

`cargo expand` で見えるコード例

基本的な async 関数と `.await` の使い方

`Future` トレイトを手動で実装するポイント

3‑1️⃣ `poll` と `Pin`／`Unpin` の意味

ピン留めの実例（`pin_project` 使用）

4‑1️⃣ `RawWaker` と安全な `Waker` の構築例

4‑2️⃣ `futures::task::ArcWake` とシングルスレッドキュー

1. `cargo expand`

2. `tokio::task::yield_now` / `async_std::task::yield_now`

3. `criterion` でベンチマーク