python theading线程开发与加锁、信号量、事件等详解

线程有2种调用方式，如下：

直接调用

 import threading
 import time
  
 def sayhi(num): #定义每个线程要运行的函数
     print("running on number:%s" %num)
     time.sleep(3)

 if __name__ == '__main__':
     t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
     t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例
     t1.start() #启动线程
     t2.start() #启动另一个线程
     print(t1.getName()) #获取线程名
     print(t2.getName())

继承式调用

import threading
import time
 
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num

    def run(self):#定义每个线程要运行的函数
        print("running on number:%s" %self.num)
        time.sleep(3)

if __name__ == '__main__':
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

同步锁（py2版本） *注：不要在3.x上运行，不知为什么，3.x上的结果总是正确的，可能是自动加了锁

 import time
 import threading

 def addNum():
     global num  # 在每个线程中都获取这个全局变量
     print('--get num: %s' %num)
     time.sleep(1)
     lock.acquire()  # 修改数据前加锁
     num -= 1  # 对此公共变量进行-1操作
     lock.release()  # 修改后释放

 num = 100  # 设定一个共享变量
 thread_list = []
 lock = threading.Lock() #生成全局锁
 for i in range(100):
     t = threading.Thread(target=addNum)
     t.start()
     print "threading num: %s \n" %threading.active_count()  #查看线程数
     thread_list.append(t)

 for t in thread_list:  # 等待所有线程执行完毕
     t.join()

 print('final num:', num)

死锁

所谓死锁：是指两个或两个以上的进程或线程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程成为死锁进程。

 import threading
 import time

 mutexA = threading.Lock()
 mutexB = threading.Lock()

 class MyThread(threading.Thread):
     def __init__(self):
         threading.Thread.__init__(self)

     def run(self):
         self.fun1()
         self.fun2()

     def fun1(self):
         mutexA.acquire()
         print("fun1 I am %s,get res:%s---%s" % (self.name, "ResA", time.time()))

         mutexB.acquire()#线程2卡在这里,获取不到锁B，线程2此时已经有锁A
         print("fun1 I am %s,get res:%s---%s" % (self.name, "ResB", time.time()))
         mutexB.release()
         print("FUN1 I am %s, release res:%s---%s" % (self.name, "ResB", time.time()))
         mutexA.release()
         print("FUN1 I am %s, release res:%s---%s" % (self.name, "ResA", time.time()))

     def fun2(self):
         mutexB.acquire()
         print("fun2 I am %s,get res:%s---%s" % (self.name, "ResB", time.time()))

         time.sleep(0.3) #这里整个进程sleep，
         print("sleep fun2 I am %s,get res:%s---%s" % (self.name, "ResB", time.time())) 

         mutexA.acquire()#线程1卡在这一步，线程1此时已经有锁b
         print("fun2 I am %s,get res:%s---%s" % (self.name, "ResA", time.time()))

         mutexA.release()
         print("FUN1 I am %s, release res:%s---%s" % (self.name, "ResA", time.time()))

         mutexB.release()
         print("FUN1 I am %s, release res:%s---%s" % (self.name, "ResB", time.time()))

 if __name__ == '__main__':
     print("start------------%s", time.time())
     for i in range(0, 10): #一次循环，代表一个线程
         print "%s \n" %i
         my_thread = MyThread()
         my_thread.start()
运行结果

0

fun1 I am Thread-1,get res:ResA---1551263063.35       #线程1获得锁B
fun1 I am Thread-1,get res:ResB---1551263063.35       #线程1获得锁B
FUN1 I am Thread-1, release res:ResB---1551263063.35  #线程1释放锁B
FUN1 I am Thread-1, release res:ResA---1551263063.35  #线程1释放锁A
fun2 I am Thread-1,get res:ResB---1551263063.35       #线程1获得锁B

1

fun1 I am Thread-2,get res:ResA---1551263063.35       #线程2释放锁A

2

..

9

sleep fun2 I am Thread-1,get res:ResB---1551263065.35 #线程2释放锁B

总结：

1、线程1已有B锁，准备获取A锁

2、线程2已有A锁，准备获取B锁

1和2同一时刻，因此互相等待

RLock（递归锁）

说白了就是在一个大锁中还要再包含子锁

在python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。

 Rlock = threading.RLock()
 class MyThread(threading.Thread):
     def __init__(self):
         threading.Thread.__init__(self)

     def run(self):
         self.fun1()
         self.fun2()

     def fun1(self):
         Rlock.acquire()  # 如果锁被占用，则阻塞在这里，等待锁的释放
         print("I am %s,get res:%s---%s" % (self.name, "ResA", time.time()))
         Rlock.acquire()  # count=2
         print("I am %s,get res:%s---%s" % (self.name, "ResB", time.time()))

         Rlock.release()  # count-1
         Rlock.release()  # count-1=0

     def fun2(self):
         Rlock.acquire()  # count=1
         print("I am %s,get res:%s---%s" % (self.name, "ResB", time.time()))
         time.sleep(0.2)

         Rlock.acquire()  # count=2
         print("I am %s,get res:%s---%s" % (self.name, "ResA", time.time()))
         Rlock.release()  # coun-1
         Rlock.release()  # count-1

 if __name__ == '__main__':
     print("start-----------%s" % time.time())
     for i in range(0, 10):
         my_thread = MyThread()
         my_thread.start()

Semaphore(信号量)

原理：来限制一个时间点内的线程数量。比如厕所有3个坑，那最多只允许3个人上厕所，后面的人只能等里面有人出来了才能再进去。

 def run(n):
     semaphore.acquire()
     time.sleep(1)
     print("run the thread: %s\n" %n)
     semaphore.release()

 if __name__ == '__main__':
     num= 0
     semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
     for i in range(20):
         t = threading.Thread(target=run,args=(i,))
         t.start()

 while threading.active_count() != 1:
     pass #print threading.active_count()
 else:
     print('----all threads done---')
     print(num)

Events

通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则。

红绿灯

 import threading,time
 import random
 def light():
     if not event.isSet():
         event.set() #wait就不阻塞 #绿灯状态
     count = 0
     while True:
         if count < 10:
             print('\033[42;1m--green light on---\033[0m')
         elif count <13:
             print('\033[43;1m--yellow light on---\033[0m')
         elif count <20:
             if event.isSet():
                 event.clear()
             print('\033[41;1m--red light on---\033[0m')
         else:
             count = 0
             event.set() #打开绿灯
         time.sleep(1)
         count +=1
 def car(n):
     while 1:
         time.sleep(random.randrange(10))
         if  event.isSet(): #绿灯
             print("car [%s] is running.." % n)
         else:
             print("car [%s] is waiting for the red light.." %n)
 if __name__ == '__main__':
     event = threading.Event()
     Light = threading.Thread(target=light)
     Light.start()
     for i in range(3):
         t = threading.Thread(target=car,args=(i,))
         t.start()

员工过门禁

 import threading
 import time
 import random

 def door():
     door_open_time_counter = 0
     while True:
         if door_swiping_event.is_set():
             print("\033[32;1mdoor opening....\033[0m")
             door_open_time_counter +=1
         else:
             print("\033[31;1mdoor closed....,please swipe to open.\033[0m")
             door_open_time_counter = 0 #清空计时器
             door_swiping_event.wait()
         if door_open_time_counter > 3:#门开了已经3s了,该关了
             door_swiping_event.clear()
         time.sleep(0.5)

 def staff(n):
     print("staff [%s] is comming..." % n )
     while True:
         if door_swiping_event.is_set():
             print("\033[34;1mdoor is opened, staff [%s] passing.....over!!\033[0m" % n )
             break
         else:
             print("STAFF [%s] sees door got closed, swipping the card....." % n)
             door_swiping_event.set()
             print("after set,,,  staff [%s]--------" %n,door_swiping_event.is_set())
         # time.sleep(0.5)

 door_swiping_event  = threading.Event() #设置事件
 door_thread = threading.Thread(target=door)
 door_thread.start()
 for i in range(5):
     p = threading.Thread(target=staff,args=(i,))
     time.sleep(random.randrange(3))
     p.start()

运行结果
door closed....,please swipe to open.
staff [0] is comming...
STAFF [0] sees door got closed, swipping the card.....
('after set,,,  staff [0]--------', True)
door is opened, staff [0] passing.....over!!
door opening....
door opening....
door opening....
door opening....
staff [1] is comming...
STAFF [1] sees door got closed, swipping the card.....
('after set,,,  staff [1]--------'staff [2] is comming...,
Truedoor is opened, staff [2] passing.....over!!)

door is opened, staff [1] passing.....over!!
door opening....
door closed....,please swipe to open.
staff [3] is comming...
STAFF [3] sees door got closed, swipping the card.....
('after set,,,  staff [3]--------', True)
door is opened, staff [3] passing.....over!!
door opening....
door opening....
staff [4] is comming...
door is opened, staff [4] passing.....over!!
door opening....
door opening....
door closed....,please swipe to open.