event = threading.Event()

# 重置event，使得所有該event事件都處于待命狀態(tài)
event.clear()

# 等待接收event的指令，決定是否阻塞程序執(zhí)行
event.wait()

# 發(fā)送event指令，使所有設置該event事件的線程執(zhí)行
event.set()

import time
import threading

class MyThread(threading.Thread):
    def __init__(self, name, event):
        super().__init__()
        self.name = name
        self.event = event

    def run(self):
        print('Thread: {} start at {}'.format(self.name, time.ctime(time.time())))
        # 等待event.set()后，才能往下執(zhí)行
        self.event.wait()
        print('Thread: {} finish at {}'.format(self.name, time.ctime(time.time())))

threads = []
event = threading.Event()

# 定義五個線程
[threads.append(MyThread(str(i), event)) for i in range(1,5)]

# 重置event，使得event.wait()起到阻塞作用
event.clear()

# 啟動所有線程
[t.start() for t in threads]

print('等待5s...')
time.sleep(5)

print('喚醒所有線程...')
event.set()

Thread: 1 start at Sun May 13 20:38:08 2018
Thread: 2 start at Sun May 13 20:38:08 2018
Thread: 3 start at Sun May 13 20:38:08 2018
Thread: 4 start at Sun May 13 20:38:08 2018

等待5s...

喚醒所有線程...
Thread: 1 finish at Sun May 13 20:38:13 2018
Thread: 4 finish at Sun May 13 20:38:13 2018
Thread: 2 finish at Sun May 13 20:38:13 2018
Thread: 3 finish at Sun May 13 20:38:13 2018

cond = threading.Condition()

# 類似lock.acquire()
cond.acquire()

# 類似lock.release()
cond.release()

# 等待指定觸發(fā)，同時會釋放對鎖的獲取,直到被notify才重新占有瑣。
cond.wait()

# 發(fā)送指定，觸發(fā)執(zhí)行
cond.notify()

import threading, time

class Hider(threading.Thread):
    def __init__(self, cond, name):
        super(Hider, self).__init__()
        self.cond = cond
        self.name = name

    def run(self):
        time.sleep(1)  #確保先運行Seeker中的方法
        self.cond.acquire()
        print(self.name + ': 我已經(jīng)把眼睛蒙上了')
        self.cond.notify()
        self.cond.wait()
        print(self.name + ': 我找到你了哦 ~_~')
        self.cond.notify() 
        self.cond.release()
        print(self.name + ': 我贏了')

class Seeker(threading.Thread):
    def __init__(self, cond, name):
        super(Seeker, self).__init__()
        self.cond = cond
        self.name = name
        
    def run(self):
        self.cond.acquire()
        self.cond.wait()
        print(self.name + ': 我已經(jīng)藏好了，你快來找我吧')
        self.cond.notify()
        self.cond.wait()
        self.cond.release()
        print(self.name + ': 被你找到了，哎~~~')
        
cond = threading.Condition()
seeker = Seeker(cond, 'seeker')
hider = Hider(cond, 'hider')
seeker.start()
hider.start()

hider:   我已經(jīng)把眼睛蒙上了
seeker:  我已經(jīng)藏好了，你快來找我吧
hider:   我找到你了 ~_~
hider:   我贏了
seeker:  被你找到了，哎~~~

from queue import Queue
# maxsize默認為0，不受限
# 一旦>0，而消息數(shù)又達到限制，q.put()也將阻塞
q = Queue(maxsize=0)

# 默認阻塞程序，等待隊列消息，可設置超時時間
q.get(block=True, timeout=None)

# 發(fā)送消息：默認會阻塞程序至隊列中有空閑位置放入數(shù)據(jù)
q.put(item, block=True, timeout=None)

# 等待所有的消息都被消費完
q.join()

# 通知隊列任務處理已經(jīng)完成，當所有任務都處理完成時，join() 阻塞將會解除
q.task_done()

# 查詢當前隊列的消息個數(shù)
q.qsize()

# 隊列消息是否都被消費完，返回 True/False
q.empty()

# 檢測隊列里消息是否已滿
q.full()

# coding=utf-8
# /usr/bin/env python

'''
Author: wangbm
Email: wongbingming@163.com
Wechat: mrbensonwon
Blog: python-online.cn
公眾號：Python編程時光
date: 2020/9/20 下午7:30
desc: 
'''
__author__ = 'wangbm'
from queue import Queue
from threading import Thread
import time
class Student:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("{}：到！".format(self.name))

class Teacher:
    def __init__(self, queue):
        super().__init__()
        self.queue=queue

    def call(self, student_name):
        if student_name == "exit":
            print("點名結束，開始上課..")
        else:
            print("老師：{}來了沒？".format(student_name))
            # 發(fā)送消息，要點誰的名
        self.queue.put(student_name)

class CallManager(Thread):
    def __init__(self, queue):
        super().__init__()
        self.students = {}
        self.queue = queue

    def put(self, student):
        self.students.setdefault(student.name, student)

    def run(self):
        while True:
            # 阻塞程序，時刻監(jiān)聽老師，接收消息
            student_name = queue.get()
            if student_name == "exit":
                break
            elif student_name in self.students:
                self.students[student_name].speak()
            else:
                print("老師，咱班，沒有 {} 這個人".format(student_name))

queue = Queue()
teacher = Teacher(queue=queue)
s1 = Student(name="小明")
s2 = Student(name="小亮")
cm = CallManager(queue)
cm.put(s1)
cm.put(s2)
cm.start()
print('開始點名~')
teacher.call('小明')
time.sleep(1)
teacher.call('小亮')
time.sleep(1)
teacher.call("exit")