tokio 分からん 2023冬

#[tokio::main]
async fn main() {
    println!("hello");
}

fn main() {
    let mut rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(async {
        println!("hello");
    })
}

async {
    println!("hello");
}

let a = async {
    3
};

trait SimpleFuture {
    type Output;
    fn poll(&mut self, wake: fn()) -> Poll<Self::Output>;
}

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

rt.block_on(async {
　　println!("hello");
})

pub(crate) fn block_on<F: Future>(&mut self, f: F) -> Result<F::Output, ParkError> {
use std::task::Context;
use std::task::Poll::Ready;

// `get_unpark()` should not return a Result
let waker = self.get_unpark()?.into_waker();
let mut cx = Context::from_waker(&waker);

pin!(f);

loop {
    if let Ready(v) = crate::coop::budget(|| f.as_mut().poll(&mut cx)) {
      return Ok(v);
    }

    self.park()?;
}

#[stable(feature = "futures_api", since = "1.36.0")]
impl<F: ?Sized + Future + Unpin> Future for &mut F {
    type Output = F::Output;

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

#[stable(feature = "futures_api", since = "1.36.0")]
impl<P> Future for Pin<P>
where
    P: ops::DerefMut<Target: Future>,
{
    type Output = <<P as ops::Deref>::Target as Future>::Output;

    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
        <P::Target as Future>::poll(self.as_deref_mut(), cx)
    }
}

rt.block_on(async {
        println!("hello");
})

#[track_caller]
pub fn block_on<F: Future>(&self, future: F) -> F::Output {
    #[cfg(all(tokio_unstable, feature = "tracing"))]
    let future = crate::util::trace::task(future, "block_on", None, task::Id::next().as_u64());
    let _ = self.enter();
    match &self.kind {
        Kind::CurrentThread(exec) => exec.block_on(future),
        #[cfg(all(feature = "rt-multi-thread", not(tokio_wasi)))]
        Kind::MultiThread(exec) => exec.block_on(future),
    }
}

/// Blocks the current thread waiting for the future to complete.
///
/// The future will execute on the current thread, but all spawned tasks
/// will be executed on the thread pool.
pub(crate) fn block_on<F>(&self, future: F) -> F::Output
where
    F: Future,
{
    let mut enter = crate::runtime::enter(true);
    enter.block_on(future).expect("failed to park thread")
}

/// Blocks the thread on the specified future, returning the value with
/// which that future completes.
pub(crate) fn block_on<F>(&mut self, f: F) -> Result<F::Output, ParkError>
where
    F: std::future::Future,
{
    use crate::park::thread::CachedParkThread;
    let mut park = CachedParkThread::new();
    park.block_on(f)
}

pub(crate) fn block_on<F: Future>(&mut self, f: F) -> Result<F::Output, ParkError> {
use std::task::Context;
use std::task::Poll::Ready;

// `get_unpark()` should not return a Result
let waker = self.get_unpark()?.into_waker();
let mut cx = Context::from_waker(&waker);

pin!(f);

loop {
    if let Ready(v) = crate::coop::budget(|| f.as_mut().poll(&mut cx)) {
      return Ok(v);
    }

    self.park()?;
}

pub(crate) fn into_waker(self) -> Waker {
    unsafe {
        let raw = unparker_to_raw_waker(self.inner);
        Waker::from_raw(raw)
    }
}

unsafe fn unparker_to_raw_waker(unparker: Arc<Inner>) -> RawWaker {
    RawWaker::new(
        Inner::into_raw(unparker),
        &RawWakerVTable::new(clone, wake, wake_by_ref, drop_waker),
    )
}

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

pub const fn new(
        clone: unsafe fn(*const ()) -> RawWaker,
        wake: unsafe fn(*const ()),
        wake_by_ref: unsafe fn(*const ()),
        drop: unsafe fn(*const ()),
) -> Self {
    Self { clone, wake, wake_by_ref, drop }
}

unsafe fn wake(raw: *const ()) {
    let unparker = Inner::from_raw(raw);
    unparker.unpark();
}

struct Inner {
    state: AtomicUsize,
    mutex: Mutex<()>,
    condvar: Condvar,
}

unsafe fn from_raw(ptr: *const ()) -> Arc<Inner> {
    Arc::from_raw(ptr as *const Inner)
}

fn unpark(&self) {
// To ensure the unparked thread will observe any writes we made before
// this call, we must perform a release operation that `park` can
// synchronize with. To do that we must write `NOTIFIED` even if `state`
// is already `NOTIFIED`. That is why this must be a swap rather than a
// compare-and-swap that returns if it reads `NOTIFIED` on failure.
match self.state.swap(NOTIFIED, SeqCst) {
    EMPTY => return,    // no one was waiting
    NOTIFIED => return, // already unparked
    PARKED => {}        // gotta go wake someone up
    _ => panic!("inconsistent state in unpark"),
}

// There is a period between when the parked thread sets `state` to
// `PARKED` (or last checked `state` in the case of a spurious wake
// up) and when it actually waits on `cvar`. If we were to notify
// during this period it would be ignored and then when the parked
// thread went to sleep it would never wake up. Fortunately, it has
// `lock` locked at this stage so we can acquire `lock` to wait until
// it is ready to receive the notification.
//
// Releasing `lock` before the call to `notify_one` means that when the
// parked thread wakes it doesn't get woken only to have to wait for us
// to release `lock`.
drop(self.mutex.lock());

self.condvar.notify_one()
    }

pub(super) fn spawn_inner<T>(future: T, name: Option<&str>) -> JoinHandle<T::Output>
    where
    T: Future + Send + 'static,
    T::Output: Send + 'static,
{
  use crate::runtime::{task, context};
  let id = task::Id::next();
  let spawn_handle = context::spawn_handle().expect(CONTEXT_MISSING_ERROR);
  let task = crate::util::trace::task(future, "task", name, id.as_u64());
  spawn_handle.spawn(task, id)
}