当多线程同时开始执行的时候，是没有先后顺序的，谁先抢到执行权谁就先执行。

通过event对象可以控制线程优先执行权。

 　　

 

event=threading.Event()

event.wait()   # event 被设定，线程则阻塞不再继续执行下去
event.set()    # event 解除设定，被阻塞的线程可以继续执行下去
event.clear()  # 如果 event被解除设定后，需要再次设定，则需要先 clear

 

 

例子： 控制一个线程先执行， 当他先执行部分任务后进行阻塞等待，并且需要其他线程再先执行的时候，则需要使用event控制。

import threading
import time

class Boss(threading.Thread):
    def __init__(self,thread_name):
        threading.Thread.__init__(self)
        self.thread_name=thread_name

    def run(self):
        print('%s:大家今晚需要加班'%self.thread_name)
        event.set()
        time.sleep(1)
        print('%s:大家可以下班了'%self.thread_name)
        event.set()


class Worker(threading.Thread):
    def __init__(self,thread_name):
        threading.Thread.__init__(self)
        self.thread_name=thread_name

    def run(self):
        event.wait()
        print('%s:命苦啊' % self.thread_name)
        event.clear()
        event.wait()
        print('%s:Oh Yeah!' % self.thread_name)



if __name__ == '__main__':

    event=threading.Event()

    threads=[]
    for i in range(5):
        t=Worker('woker%s'%i)
        threads.append(t)
    threads.append(Boss('boss'))

    for t in threads:
        t.start()
    for t in threads:
        t.join()

 

 信号控制量， 即同时可以设置有多少个线程执行任务

　　

import threading
import time

class MyThread(threading.Thread):
    def __init__(self,thread_name):
        threading.Thread.__init__(self)
        self.thread_name=thread_name

    def run(self):
        if semaphore.acquire():
            time.sleep(1)
            print(self.thread_name)
            semaphore.release()



if __name__ == '__main__':

    semaphore=threading.Semaphore(5)

    threads=[]
    for i in range(100):
        t=MyThread('thread%s'%i)
        threads.append(t)


    for t in threads:
        t.start()
    for t in threads:
        t.join()