Python--同步锁（互斥锁）、死锁（状态）、递归锁、信号量、Event对象

同步锁/互斥锁 (Lock)

import time
import threading

def sub():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    time.sleep(0.1)
    num =temp-1  # 对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):
    t = threading.Thread(target=sub)
    t.start()
    thread_list.append(t)

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

print('Result: ', num)
运行结果：
99

我们想要的结果是多线程实现递减至0 ，但是很明显没有实现。

下面这段代码更改了一下睡眠时间，依然结果不会是0 。

import time
import threading

def sub():
    global num #在每个线程中都获取这个全局变量
    #num-=1

    temp=num
    time.sleep(0.001)
    num =temp-1  # 对此公共变量进行-1操作

num = 100  #设定一个共享变量

thread_list = []

for i in range(100):
    t = threading.Thread(target=sub)
    t.start()
    thread_list.append(t)

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

print('Result: ', num)
运行结果：
大于0 但是小于100的数

锁通常被用来实现对共享资源的同步访问。

import threading

R=threading.Lock() #为每一个共享资源创建一个Lock对象

R.acquire() #当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放）
'''
对公共数据的操作
'''
R.release() #待资源访问完后，再调用release方法释放锁：

import time
import threading

def sub():
    global num #在每个线程中都获取这个全局变量

    lock.acquire()
    temp=num
    time.sleep(0.001)
    num =temp-1  # 对此公共变量进行-1操作
    lock.release()

num = 100  #设定一个共享变量
thread_list = []
lock=threading.Lock()

for i in range(100):
    t = threading.Thread(target=sub)
    t.start()
    thread_list.append(t)

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

print('Result: ', num)
运行结果：
Result:  0

这样就解决了我们的问题。

为什么有了GIL，还需要线程同步？

多线程环境下必须存在资源的竞争,那么如何才能保证同一时刻只有一个线程对共享资源进行存取?

加锁, 对, 加锁可以保证存取操作的唯一性, 从而保证同一时刻只有一个线程对共享数据存取.

死锁与递归锁

import time
import threading
class Mythread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()

    def foo(self):
        locka.acquire()
        print('I am %s got locka---%s'%(self.name,time.ctime()))

        lockb.acquire()
        print('I am %s got lockb---%s'%(self.name,time.ctime()))

        lockb.release()
        locka.release()

if __name__ == '__main__':
    locka=threading.Lock()
    lockb=threading.Lock()

    for i in range(10):
        t=Mythread()
        t.start()
运行效果：
I am Thread-1 got locka---Fri Jul 21 14:30:32 2017
I am Thread-1 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-2 got locka---Fri Jul 21 14:30:32 2017
I am Thread-2 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-3 got locka---Fri Jul 21 14:30:32 2017
I am Thread-3 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-4 got locka---Fri Jul 21 14:30:32 2017
I am Thread-4 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-5 got locka---Fri Jul 21 14:30:32 2017
I am Thread-5 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-6 got locka---Fri Jul 21 14:30:32 2017
I am Thread-6 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-7 got locka---Fri Jul 21 14:30:32 2017
I am Thread-7 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-8 got locka---Fri Jul 21 14:30:32 2017
I am Thread-8 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-9 got locka---Fri Jul 21 14:30:32 2017
I am Thread-9 got lockb---Fri Jul 21 14:30:32 2017
I am Thread-10 got locka---Fri Jul 21 14:30:32 2017
I am Thread-10 got lockb---Fri Jul 21 14:30:32 2017

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

import time
import threading
class Mythread(threading.Thread):
    def __init__(self):
        threading.Thread.__init__(self)

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        locka.acquire()
        print('I am %s got locka---%s'%(self.name,time.ctime()))

        lockb.acquire()
        print('I am %s got lockb---%s'%(self.name,time.ctime()))

        lockb.release()
        locka.release()

    def bar(self):
        lockb.acquire()
        print('I am %s got lockb---%s'%(self.name,time.ctime()))

        locka.acquire()
        print('I am %s got locka---%s'%(self.name,time.ctime()))

        locka.release()
        lockb.release()

if __name__ == '__main__':
    locka=threading.Lock()
    lockb=threading.Lock()

    for i in range(10):
        t=Mythread()
        t.start()

运行效果图：

解决死锁状态的递归锁出现了。

在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。

这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

import time
import threading

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

    def run(self):
        self.foo()
        self.bar()

    def foo(self):
        Rlock.acquire()
        print('I am %s got locka---%s'%(self.name,time.ctime()))

        Rlock.acquire()
        print('I am %s got lockb---%s'%(self.name,time.ctime()))

        Rlock.release()
        Rlock.release()

    def bar(self):
        Rlock.acquire()
        print('I am %s got lockb---%s'%(self.name,time.ctime()))

        Rlock.acquire()
        print('I am %s got locka---%s'%(self.name,time.ctime()))

        Rlock.release()
        Rlock.release()

if __name__ == '__main__':
    Rlock=threading.RLock()

    for i in range(10):
        t=Mythread()
        t.start()
运行效果：
I am Thread-1 got locka---Fri Jul 21 14:42:08 2017
I am Thread-1 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-2 got locka---Fri Jul 21 14:42:08 2017
I am Thread-2 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-2 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-2 got locka---Fri Jul 21 14:42:08 2017
I am Thread-1 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-1 got locka---Fri Jul 21 14:42:08 2017
I am Thread-3 got locka---Fri Jul 21 14:42:08 2017
I am Thread-3 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-4 got locka---Fri Jul 21 14:42:08 2017
I am Thread-4 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-5 got locka---Fri Jul 21 14:42:08 2017
I am Thread-5 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-3 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-3 got locka---Fri Jul 21 14:42:08 2017
I am Thread-6 got locka---Fri Jul 21 14:42:08 2017
I am Thread-6 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-6 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-6 got locka---Fri Jul 21 14:42:08 2017
I am Thread-4 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-4 got locka---Fri Jul 21 14:42:08 2017
I am Thread-7 got locka---Fri Jul 21 14:42:08 2017
I am Thread-7 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-7 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-7 got locka---Fri Jul 21 14:42:08 2017
I am Thread-9 got locka---Fri Jul 21 14:42:08 2017
I am Thread-9 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-9 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-9 got locka---Fri Jul 21 14:42:08 2017
I am Thread-5 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-5 got locka---Fri Jul 21 14:42:08 2017
I am Thread-10 got locka---Fri Jul 21 14:42:08 2017
I am Thread-10 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-10 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-10 got locka---Fri Jul 21 14:42:08 2017
I am Thread-8 got locka---Fri Jul 21 14:42:08 2017
I am Thread-8 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-8 got lockb---Fri Jul 21 14:42:08 2017
I am Thread-8 got locka---Fri Jul 21 14:42:08 2017

Semaphore（信号量）

Semaphore管理一个内置的计数器，
每当调用acquire()时内置计数器-1；
调用release() 时内置计数器+1；
计数器不能小于0；当计数器为0时，acquire()将阻塞线程直到其他线程调用release()。

实例：(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5)：

import threading
import time

semaphore =threading.Semaphore(5) #同时只有5个线程可以获得semaphore,即可以限制最大连接数为5

def foo():
    semaphore.acquire()
    time.sleep(2)
    print('ok')
    semaphore.release()

for i in range(10):
    t=threading.Thread(target=foo)
    t.start()
运行效果：
先同时打印5个‘ok’,过两秒再同时打印5个‘ok’

Event对象

线程的一个关键特性是每个线程都是独立运行且状态不可预测。

如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就 会变得非常棘手。为了解决这些问题,我们需要使用threading库中的Event对象。

在 初始情况下,Event对象中的信号标志被设置为假。

如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。

一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。

如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行

event.isSet()：返回event的状态值；

event.wait()：如果 event.isSet()==False将阻塞线程；

event.set()： 设置event的状态值为True，所有阻塞池的线程激活进入就绪状态， 等待操作系统调度；

event.clear()：恢复event的状态值为False。

import threading,time

event=threading.Event()

def foo():
    print('waitting...')
    event.wait()
    print('connect to redis server')

for i in range(5):
    t=threading.Thread(target=foo)
    t.start()

print('attempt to start redis server')
time.sleep(3)

event.set()
运行效果：
先同时打印5个'waiting'和'attempt to start redis server',3秒后打印5个'connect to redis server'

threading.Event的wait方法还接受一个超时参数，默认情况下如果事件一直没有发生，wait方法会一直阻塞下去，而加入这个超时参数之后，如果阻塞时间超过这个参数设定的值之后，wait方法会返回。

import threading,time

event=threading.Event()

def foo():
    print('waitting...')
    event.wait(1)
    print('cinnect to redis server')

for i in range(5):
    t=threading.Thread(target=foo)
    t.start()

print('attempt to start redis server')
time.sleep(3)

event.set()
运行效果：
先同时打印5个‘waitting’，1个‘attempt to start redis server’，过1秒打印'cinnect to redis server'，再过两秒程序运行结束