import asyncio
async def main():
    await asyncio.sleep(0)
asyncio.run(main())

class Runner:
    ...
    def run(self, coro, *, context=None):
        """Run a coroutine inside the embedded event loop."""
        # 省略代碼
        ...

        # 把coroutine轉(zhuǎn)為task
        task = self._loop.create_task(coro, context=context)

        # 省略代碼
        ...

        try:
            # 如果傳入的是Future或者coroutine，也會專為task
            return self._loop.run_until_complete(task)
        except exceptions.CancelledError:

        # 省略代碼
        ...

import asyncio
async def main():
    await asyncio.create_task(asyncio.sleep(0))
asyncio.run(main())

# demo_coro.py
import asyncio
import time
async def main():
    await asyncio.sleep(1)
    await asyncio.sleep(2)
s_t = time.time()
asyncio.run(main())
print(time.time() - s_t)
# // Output: 3.0028765201568604
# demo_task.py
import asyncio
import time
async def main():
    task_1 = asyncio.create_task(asyncio.sleep(1))
    task_2 = asyncio.create_task(asyncio.sleep(2))
    await task_1
    await task_2

s_t = time.time()
asyncio.run(main())
print(time.time() - s_t)
# // Output: 2.0027475357055664

class Future:
    ...
    def set_result(self, result):
        """設(shè)置結(jié)果，并安排下一個調(diào)用"""
        if self._state != _PENDING:
            raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
        self._result = result
        self._state = _FINISHED
        self.__schedule_callbacks()
    def set_exception(self, exception):
        """設(shè)置異常，并安排下一個調(diào)用"""
        if self._state != _PENDING:
            raise exceptions.InvalidStateError(f'{self._state}: {self!r}')
        if isinstance(exception, type):
            exception = exception()
        if type(exception) is StopIteration:
            raise TypeError("StopIteration interacts badly with generators "
                            "and cannot be raised into a Future")
        self._exception = exception
        self._state = _FINISHED
        self.__schedule_callbacks()
        self.__log_traceback = True
    def __await__(self):
        """設(shè)置為blocking，并接受await或者yield from調(diào)用"""
        if not self.done():
            self._asyncio_future_blocking = True
            yield self  # This tells Task to wait for completion.
        if not self.done():
            raise RuntimeError("await wasn't used with future")
        return self.result()  # May raise too.

    __iter__ = __await__  # make compatible with 'yield from'.

async def demo(future: asyncio.Future):
    await future
    print("aha")

class Task(futures._PyFuture):  # Inherit Python Task implementation                            # from a Python Future implementation.
    _log_destroy_pending = True
    def __init__(self, coro, *, loop=None, name=None, context=None):
        super().__init__(loop=loop)
        # 省略部分初始化代碼
        ...
        # 托管的coroutine
        self._coro = coro
        if context is None:
            self._context = contextvars.copy_context()
        else:
            self._context = context
        # 通過loop.call_sonn，在Task初始化后馬上就通知事件循環(huán)在下次有空的時候執(zhí)行自己的__step函數(shù)
        self._loop.call_soon(self.__step, context=self._context)
    def __step(self, exc=None):
        coro = self._coro
        # 方便asyncio自省
        _enter_task(self._loop, self)
        # Call either coro.throw(exc) or coro.send(None).
        try:
            if exc is None:
                # 通過send預(yù)激托管的coroutine
                # 這時候只會得到coroutine yield回來的數(shù)據(jù)或者收到一個StopIteration的異常
                # 對于Future或者Task返回的是Self
                result = coro.send(None)
            else:
                # 發(fā)送異常給coroutine 
                result = coro.throw(exc)
        except StopIteration as exc:
            # StopIteration代表Coroutine運行完畢
            if self._must_cancel:
                # coroutine在停止之前被執(zhí)行了取消操作，則需要顯示的執(zhí)行取消操作
                self._must_cancel = False
                super().cancel(msg=self._cancel_message)
            else:
                # 把運行完畢的值發(fā)送到結(jié)果值中
                super().set_result(exc.value)
        # 省略其它異常封裝
        ...
        else:
            # 如果沒有異常拋出
            blocking = getattr(result, '_asyncio_future_blocking', None)
            if blocking is not None:
                # 通過Future代碼可以判斷，如果帶有_asyncio_future_blocking屬性，則代表當(dāng)前result是Future或者是Task
                # 意味著這個Task里面裹著另外一個的Future或者Task
                # 省略Future判斷
                ...

                if blocking:
                    # 代表這這個Future或者Task處于卡住的狀態(tài)，
                    # 此時的Task放棄了自己對事件循環(huán)的控制權(quán)，等待這個卡住的Future或者Task執(zhí)行完成時喚醒一下自己
                    result._asyncio_future_blocking = False
                    result.add_done_callback(self.__wakeup, context=self._context)
                    self._fut_waiter = result
                    if self._must_cancel:
                        if self._fut_waiter.cancel(msg=self._cancel_message):
                            self._must_cancel = False
                else:
                    # 不能被await兩次
                    new_exc = RuntimeError(
                        f'yield was used instead of yield from '
                        f'in task {self!r} with {result!r}')
                    self._loop.call_soon(
                        self.__step, new_exc, context=self._context)

            elif result is None:
                # 放棄了對事件循環(huán)的控制權(quán)，代表自己托管的coroutine可能有個coroutine在運行，接下來會把控制權(quán)交給他和事件循環(huán) 
                # 當(dāng)前的coroutine里面即使沒有Future或者Task,但是子Future可能有
                self._loop.call_soon(self.__step, context=self._context)
        finally:
            _leave_task(self._loop, self)
            self = None  # Needed to break cycles when an exception occurs.

    def __wakeup(self, future):
        # 其它Task和Future完成后會調(diào)用到該函數(shù)，接下來進(jìn)行一些處理
        try:
            # 回收Future的狀態(tài)，如果Future發(fā)生了異常，則把異常傳回給自己
            future.result()
        except BaseException as exc:
            # This may also be a cancellation.
            self.__step(exc)
        else:
            # Task并不需要自己托管的Future的結(jié)果值，而且如下注釋，這樣能使調(diào)度變得更快
            # Don't pass the value of `future.result()` explicitly,
            # as `Future.__iter__` and `Future.__await__` don't need it.
            # If we call `_step(value, None)` instead of `_step()`,
            # Python eval loop would use `.send(value)` method call,
            # instead of `__next__()`, which is slower for futures
            # that return non-generator iterators from their `__iter__`.
            self.__step()
        self = None  # Needed to break cycles when an exception occurs.

# demo_coro.py
import asyncio
import time
async def main():
    await asyncio.sleep(1)
    await asyncio.sleep(2)
s_t = time.time()
asyncio.run(main())
print(time.time() - s_t)
# // Output: 3.0028765201568604

# demo_task.py
import asyncio
import time
async def main():
    task_1 = asyncio.create_task(asyncio.sleep(1))
    task_2 = asyncio.create_task(asyncio.sleep(2))
    await task_1
    await task_2
s_t = time.time()
asyncio.run(main())
print(time.time() - s_t)
# // Output: 2.0027475357055664

# demo_task.py
import asyncio
import time
def mutli_task():
    task_1 = asyncio.create_task(asyncio.sleep(1))
    task_2 = asyncio.create_task(asyncio.sleep(2))
async def main():
    mutli_task()
    await asyncio.sleep(1.5) 
s_t = time.time()
asyncio.run(main())
print(time.time() - s_t)
# // Output: 1.5027475357055664