async await 异步编程

enum Poll<T> {
    Ready(T),
    Pending,
}

struct Context<'a> {
    waker: &'Waker,
    _maker: PhantomData<fn (&'a ()) -> &'a()>
}


trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, context: &Context<'_>) -> Poll<Self::Output>
}

impl Waker {
    /// Wake up the task associated with this `Waker`.
    #[inline]
    #[stable(feature = "futures_api", since = "1.36.0")]
    pub fn wake(self) {
        // The actual wakeup call is delegated through a virtual function call
        // to the implementation which is defined by the executor.
        let wake = self.waker.vtable.wake;
        let data = self.waker.data;

        // Don't call `drop` -- the waker will be consumed by `wake`.
        crate::mem::forget(self);

        // SAFETY: This is safe because `Waker::from_raw` is the only way
        // to initialize `wake` and `data` requiring the user to acknowledge
        // that the contract of `RawWaker` is upheld.
        unsafe { (wake)(data) };
    }
    ...
}

use std:: {
    future::Future,
    sync::{Arc, Mutex, mpsc::{SyncSender, sync_channel, Receiver}},
    task::{ Context, Poll, Waker },
    thread,
    time::Duration,
    marker::Send
};

use futures::{future::BoxFuture, FutureExt, task::{ArcWake, waker_ref} };

struct ShareData {
    completed: bool,
    waker: Option<Waker>,
}

struct  TimerFuture {
    data: Arc<Mutex<ShareData>>
}

impl Future for TimerFuture {
    type Output = ();
    fn poll(self: std::pin::Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        let mut share_data = self.data.lock().unwrap();
        if share_data.completed {
           Poll::Ready(())
        }else{
            share_data.waker = Some(cx.waker().clone());
           Poll::Pending
        }
    }
}

impl TimerFuture {
    fn new(dur: Duration)->Self {
        let share_data = Arc::new(Mutex::new(ShareData{
            completed: false,
            waker: None
        }));
        let thread_share_data = share_data.clone();
        thread::spawn(move || {
            thread::sleep(dur);
            let mut data = thread_share_data.lock().unwrap();
            data.completed = true;
            if let Some(waker) = data.waker.take() {
                waker.wake();
            }
        });

        TimerFuture { data: share_data }
    }
}

struct  Exector {
    ready_queue: Receiver<Arc<Task>>
}

struct Spwaner {
    task_sender: SyncSender<Arc<Task>>
}
impl Spwaner {
    fn spawn(&self, future: impl Future<Output = ()> + 'static + Send){
        let future = future.boxed();
        let task = Arc::new(Task{
            future: Mutex::new(Some(future)),
            sender: self.task_sender.clone(),
        });
        self.task_sender.send(task).expect("task is full");
    }
}

struct Task {
    future:  Mutex<Option<BoxFuture<'static, ()>>>,
    sender: SyncSender<Arc<Task>>
} 
impl ArcWake for Task {
    fn wake_by_ref(arc_self: &Arc<Self>) {
        let cloned = arc_self.clone();
        arc_self.sender.send(cloned).expect("oops!, task is full");
    }
}

impl Exector {
    fn run(&self){
        while let Ok(task) = self.ready_queue.recv() {
            let mut future_slot = task.future.lock().unwrap();
            if let Some(mut future) = future_slot.take() {
                let waker = waker_ref(&task);
                let context = &mut  Context::from_waker(&*waker);
                if future.as_mut().poll(context).is_pending() {
                    *future_slot = Some(future);
                }
            }
        }
    }
}

fn new_exector_and_spwanr ()-> (Exector, Spwaner) {
   
    const MAX_QUEUE : usize= 2;
    let (task_sender, ready_queue) = sync_channel(MAX_QUEUE);
    return (Exector{ ready_queue }, Spwaner{ task_sender }); 
}

fn main(){
    let (exector, spwaner) = new_exector_and_spwanr();

    spwaner.spawn(async {
        println!("Hey1");
        TimerFuture::new(Duration::from_secs(1)).await; 
        println!("done2");
    });
    spwaner.spawn(async {
        println!("Hey2");
        TimerFuture::new(Duration::from_secs(1)).await; 
        println!("done2");
    });

    drop(spwaner);

    exector.run();
}

Compiling playground v0.0.1 (/playground)
    Finished dev [unoptimized + debuginfo] target(s) in 2.04s
     Running `target/debug/playground`

Hey1
Hey2
done2
done2