有关多线程(同步锁，递归锁，同步对象，信号量)

上面一个随笔已经简单介绍了多线程，比如下面在举个简单的例子：

#!/usr/bin/env python
#-*-coding:utf-8 -*-

import threading
import time

def add():
    sum = 0

    for i in range(1000000):
        sum += i

    print("sum: ",sum)


def mul():
    sum2 = 1
    for i in range(1,100000):
        sum2 *= i

    print("sum2: ",sum2)


if __name__ == '__main__':

    start = time.time()
    t1 = threading.Thread(target=add)
    t2 = threading.Thread(target=mul)

    l = []
    l.append(t1)
    l.append(t2)

    for t in l:
        t.start()

    for t in l:
        t.join()

    print("cost time %s"%(time.time()-start))

但是当多线程处理共享数据等问题时，简单的多线程会遇到一些困难，比如：

import threading
import time

def sub():

    global num

    # num -= 1
    temp = num          # 一下三行与上一行意思一样，只是加了一个时间
    time.sleep(0.0001)
    num = temp-1
'''
这样结果就不像原来的0了，原因是，原来线程1过来减1后，num少一，没问题；
现在加了.sleep(),当线程1到temp = num 时，因为到等待，所以切换给下一个线程，线程2拿到的还是100，
等第一线程到num = temp -1 = 99 时，下一个线程的temp还是100。
一个线程cpu还没处理结束，交出处理权,但是它们共享一个数据，所以可能出错。
解决办法，执行上面三行的过程中，CPU不可以切换，就OK了，因此同步锁诞生。详细见lesson3
'''

num = 100

l = []

for i in range(100):         # 开了一百个线程
    t = threading.Thread(target=sub)
    t.start()
    l.append(t)

for j in l:
    j.join()

因此对于这种情况需要用同步锁，lock = threading.Lock() 定义锁, lock.acquire()上锁，lock.release()开锁。锁之间内容等于变成串行。使用如下：

import threading
import time

def sub():

    global num

    # num -= 1
    lock.acquire()      # 加上同步锁，意思是，在释放锁前的内容不可以进行CPU线程切换

    temp = num          # 一下三行与上一行意思一样，只是加了一个时间
    time.sleep(0.001)
    num = temp-1

    lock.release()

num = 100

l = []
lock = threading.Lock()

for i in range(100):         # 开了一百个线程
    t = threading.Thread(target=sub)
    t.start()
    l.append(t)

for j in l:
    j.join()

print(num)

 

以上说明了为什么需要同步锁，以及它的使用方法，但是在多线程中还有死锁的问题。死锁：在线程见共享拿多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方资源就会造成死锁。比如：下面例子，线程1拿actionB中的B锁后，sleep()时间切换线程，线程2拿了actionA中A锁后，在拿B锁时，发现没有B锁（还在线程1手里），造成死锁。

import  threading,time


# 用继承类创建多线程

class MyThread(threading.Thread):

    def actionA(self):
        A.acquire()
        print(self.name,"gotA",time.ctime())       # self.name是线程名
        time.sleep(2)
        # 注意A锁还没释放，又上了一把锁
        B.acquire()
        print(self.name,"gotB",time.ctime())
        time.sleep(1)

        B.release()
        A.release()

    def actionB(self):
        B.acquire()
        print(self.name, "gotB", time.ctime())
        time.sleep(2)
        # 注意A锁还没释放，又上了一把锁
        A.acquire()
        print(self.name, "gotB", time.ctime())
        time.sleep(1)

        A.release()
        B.release()

    def run(self):      # run函数名字必须这样，就跟之前handle一个意思
        self.actionA()
        time.sleep(2)
        self.actionB()


if __name__ == '__main__':

    # 定义两把锁，注意是两把，不是两种，只要两个，你用A的同时，它就不可以
    A = threading.Lock()
    B = threading.Lock()

    L = []

    for i in range(5):     # 开了五个线程
        t = MyThread()
        t.start()
        L.append(t)

    for t in L:
        t.join()

使用递归锁可以解决问题，threading.Rlock(),内部就是多一个计数，acquire一次，内部计数加一个1，release减1，只有计数等于0时，其他线程才可以拿这把锁，不然等待。自己线程可以多次用这个锁。具体如下：

import  threading,time


# 用继承类创建多线程

class MyThread(threading.Thread):

    def actionA(self):
        r_lock.acquire()
        print(self.name,"gotA",time.ctime())       # self.name是线程名
        time.sleep(2)
        # 注意A锁还没释放，又上了一把锁
        r_lock.acquire()
        print(self.name,"gotB",time.ctime())
        time.sleep(1)

        r_lock.release()
        r_lock.release()

    def actionB(self):
        r_lock.acquire()
        print(self.name, "gotB", time.ctime())
        time.sleep(2)
        # 注意A锁还没释放，又上了一把锁
        r_lock.acquire()
        print(self.name, "gotB", time.ctime())
        time.sleep(1)

        r_lock.release()
        r_lock.release()

    def run(self):      # run函数名字必须这样，就跟之前handle一个意思
        self.actionA()
        self.actionB()


if __name__ == '__main__':

    # 定义两把锁，注意是两把，不是两种，只要两个，你用A的同时，它就不可以
    # A = threading.Lock()
    # B = threading.Lock()

    r_lock = threading.RLock()

    L = []

    for i in range(5):     # 开了五个线程
        t = MyThread()
        t.start()
        L.append(t)

    for t in L:
        t.join()

    print("ending.........")

 

有了同步锁（threading.Lock），递归锁（threading.Rlock）,下面介绍threading.Event。说这个之前，先说一下同步对象的概念：当你同时开五个线程执行任务的时候，到底哪个任务先执行，是由抢占CPU决定的，不可控。但是有时候需求需要其中一个特定的线程任务完成到一定阶段，其他线程才可以开始。这时候就涉及到同步对象的概念。

创建同步对象：event = threading.Event()
                         event.set() 设定
                         event.wait() 如果之前没设定，到这步就阻塞等待；如果已经设定，这步等于pass(跳过)
                         event.clear() 清除设定

import threading,time
class Boss(threading.Thread):

    def run(self):
        print("BOSS：今晚大家都要加班到22:00。")
        print(event.isSet())# False
        event.set()
        time.sleep(5)
        print("BOSS：<22:00>可以下班了。")
        print(event.isSet())
        event.set()

class Worker(threading.Thread):
    def run(self):

        event.wait()#    一旦event被设定，等同于pass

        print("Worker：哎……命苦啊！")
        time.sleep(1)
        event.clear()
        event.wait()
        print("Worker：OhYeah!")


if __name__=="__main__":
    event=threading.Event()


    threads=[]
    for i in range(5):
        threads.append(Worker())
    threads.append(Boss())
    for t in threads:         # 本来这6个线程随先执行是随意的（如果没有Event）,但是需求肯定是先是老板说加班，员工叫苦，老板说下班，员工欢呼
        t.start()
    for t in threads:
        t.join()

    print("ending.....")

 

实际应用中可能还有一个信号量的事，也就是允许同时运行的最大线程数目。

import threading,time


class myThread(threading.Thread):
    def run(self):

        if semaphore.acquire():
            print(self.name)
            time.sleep(3)
            semaphore.release()

if __name__=="__main__":
    semaphore=threading.Semaphore(5)
    # semaphore也是一把锁，里面数字代表对于一个加锁任务允许执行的最大线程数
    thrs=[]
    for i in range(100):
        thrs.append(myThread())
    for t in thrs:
        t.start()