import threading

# 条件变量,用于复杂的线程间同步锁

"""

需求:

    男:小姐姐,你好呀!

    女:哼,想泡老娘不成?

    男:对呀,想泡你

    女:滚蛋,门都没有!

    男:切,长这么丑, 还这么吊...

    女:关你鸟事!

"""

class Boy(threading.Thread):

    def __init__(self, name, condition):

        super().__init__(name=name)

        self.condition = condition

    def run(self):

        with self.condition:

            print("{}:小姐姐,你好呀!".format(self.name))

            self.condition.wait()

            self.condition.notify()

            print("{}:对呀,想泡你".format(self.name))

            self.condition.wait()

            self.condition.notify()

            print("{}:切,长这么丑, 还这么吊...".format(self.name))

            self.condition.wait()

            self.condition.notify()

class Girl(threading.Thread):

    def __init__(self, name, condition):

        super().__init__(name=name)

        self.condition = condition

    def run(self):

        with self.condition:

            print("{}:哼,想泡老娘不成?".format(self.name))

            self.condition.notify()

            self.condition.wait()

            print("{}:滚蛋,门都没有!".format(self.name))

            self.condition.notify()

            self.condition.wait()

            print("{}:关你鸟事!".format(self.name))

            self.condition.notify()

            self.condition.wait()

if __name__ == '__main__':

    condition = threading.Condition()

    boy_thread = Boy('男', condition)

    girl_thread = Girl('女', condition)

    boy_thread.start()

    girl_thread.start()

  def __enter__(self):

        return self._lock.__enter__()

   def __exit__(self, *args):

        return self._lock.__exit__(*args)

 def __exit__(self, t, v, tb):

        self.release()

 def release(self):

        """Release a lock, decrementing the recursion level.

        If after the decrement it is zero, reset the lock to unlocked (not owned

        by any thread), and if any other threads are blocked waiting for the

        lock to become unlocked, allow exactly one of them to proceed. If after

        the decrement the recursion level is still nonzero, the lock remains

        locked and owned by the calling thread.

        Only call this method when the calling thread owns the lock. A

        RuntimeError is raised if this method is called when the lock is

        unlocked.

        There is no return value.

        """

        if self._owner != get_ident():

            raise RuntimeError("cannot release un-acquired lock")

        self._count = count = self._count - 1

        if not count:

            self._owner = None

            self._block.release()

waiter = _allocate_lock()  #从底层获取了一把锁,并非Lock锁

waiter.acquire()

self._waiters.append(waiter)  # 然后将这个锁加入到_waiters(deque)中

saved_state = self._release_save()  # 这是释放__enter__时的那把锁???

all_waiters = self._waiters

waiters_to_notify = _deque(_islice(all_waiters, n))# 从_waiters中取出n个

if not waiters_to_notify:    # 如果是None,结束

      return

for waiter in waiters_to_notify: # 循环release

      waiter.release()

      try:

          all_waiters.remove(waiter)  #从_waiters中移除

      except ValueError:

          pass