asyncio系列之Lock实现

 import types
 import select
 import time
 import socket
 import functools
 import collections

 class Future:
     def __init__(self, *, loop=None):
         self._result = None
         self._callbacks = []
         self._loop = loop

     def set_result(self, result):
         self._result = result
         callbacks = self._callbacks[:]
         self._callbacks = []
         for callback in callbacks:
             self._loop._ready.append(callback)

     def add_callback(self, callback):
         self._callbacks.append(callback)

     def __iter__(self):
         print("挂起在yield处")
         yield self
         print("恢复执行")
         return "future"

     __await__ = __iter__

 class Task:
     def __init__(self, cor, *, loop=None):
         self.cor = cor
         self._loop = loop

     def _step(self):
         cor = self.cor
         try:
             result = cor.send(None)
         except StopIteration as e:
             self._loop._task_count -= 1
             if self._loop._task_count == 0:
                 self._loop.close()
         except Exception as e:
             pass
         else:
             if isinstance(result, Future):
                 result.add_callback(self._wakeup)

     def _wakeup(self):
         self._step()

 class Loop:
     def __init__(self):
         self._stop = False
         self._ready = []
         self._scheduled = []
         self._time = lambda: time.time()
         sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         sock.setblocking(False)
         self._select = functools.partial(select.select, [sock], [], [])
         self._task_count = 0

     def create_task(self, cor):
         task = Task(cor, loop=self)
         self._ready.append(task._step)
         self._task_count += 1
         return task

     def call_later(self, delay, callback, *args):
         callback._when = delay
         self._scheduled.append((callback, *args))

     def run_until_complete(self, task):
         assert isinstance(task, Task)
         timeout = None
         while not self._stop:
             if self._ready:
                 timeout = 0
             if self._scheduled:
                 callback, *args = self._scheduled.pop()
                 timeout = callback._when
                 self._ready.append(functools.partial(callback, *args))

                 self._select(timeout)
             n = len(self._ready)
             for i in range(n):
                 step = self._ready.pop()
                 step()

     def close(self):
         self._stop = True

 @types.coroutine
 def _sleep():
     yield

 async def sleep(s, result=None):
     if s <= 0:
         await _sleep()
         return result
     else:
         future = Future(loop=loop)
         future._loop.call_later(s, unless_cancelled, future)
         await future
         return result

 def unless_cancelled(future):
     future.set_result(None)

 class Lock:
     def __init__(self, *, loop=None):
         self._waiters = collections.deque()
         self._locked = False
         self._loop = loop

     def __repr__(self):
         extra = 'locked' if self._locked else 'unlocked'
         if self._waiters:
             extra = '{},waiters:{}'.format(extra, len(self._waiters))
         return '<[{}]>'.format(extra)

     def locked(self):
         """Return True if lock is acquired."""
         return self._locked

     @types.coroutine
     def acquire(self):
         if not self._locked:
             self._locked = True
             return True

         fut = Future(loop=self._loop)
         self._waiters.append(fut)

         try:
             yield from fut
         finally:
             self._waiters.remove(fut)

         self._locked = True
         return True

     def release(self):
         if self._locked:
             self._locked = False
             self._wake_up_first()
         else:
             raise RuntimeError('Lock is not acquired.')

     def _wake_up_first(self):
         """Wake up the first waiter if it isn't done."""
         try:
             fut = next(iter(self._waiters))
         except StopIteration:
             return

         fut.set_result(True)

 async def foo(look):
     await look.acquire()
     print(f'enter foo at {time.strftime("%Y-%m-%d %H:%M:%S")}')
     await sleep(1)
     print(f'exit foo at {time.strftime("%Y-%m-%d %H:%M:%S")}')
     look.release()

 async def goo(look):
     await look.acquire()
     print(f'enter goo at {time.strftime("%Y-%m-%d %H:%M:%S")}')
     await sleep(1)
     print(f'exit goo at {time.strftime("%Y-%m-%d %H:%M:%S")}')
     look.release()

 if __name__ == '__main__':
     loop = Loop()
     look = Lock(loop=loop)
     f = foo(look)
     g = goo(look)
     task1 = loop.create_task(f)
     task2 = loop.create_task(g)
     loop.run_until_complete(task1)