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 
" %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 
" %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)
    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('33[42;1m--green light on---33[0m')
        elif count <13:
            print('33[43;1m--yellow light on---33[0m')
        elif count <20:
            if event.isSet():
                event.clear()
            print('33[41;1m--red light on---33[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("33[32;1mdoor opening....33[0m")
            door_open_time_counter +=1
        else:
            print("33[31;1mdoor closed....,please swipe to open.33[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("33[34;1mdoor is opened, staff [%s] passing.....over!!33[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.