python多线程(三)

同步锁

两个需要注意的点：

线程抢的是GIL锁，GIL锁相当于执行权限，拿到执行权限后才能拿到互斥锁Lock，其他线程也可以抢到GIL，但如果发现Lock仍然没有被释放则阻塞，即便是拿到执行权限GIL也要立刻交出来
join是等待所有，即整体串行，而锁只是锁住修改共享数据的部分，即部分串行，要想保证数据安全的根本原理在于让并发变成串行，join与互斥锁都可以实现，毫无疑问，互斥锁的部分串行效率要更高

GIL VS Lock

机智的同学可能会问到这个问题，就是既然你之前说过了，Python已经有一个GIL来保证同一时间只能有一个线程来执行了，为什么这里还需要lock?

　首先我们需要达成共识：锁的目的是为了保护共享的数据，同一时间只能有一个线程来修改共享的数据

然后，我们可以得出结论：保护不同的数据就应该加不同的锁。

　最后，问题就很明朗了，GIL 与Lock是两把锁，保护的数据不一样，前者是解释器级别的（当然保护的就是解释器级别的数据，比如垃圾回收的数据），后者是保护用户自己开发的应用程序的数据，很明显GIL不负责这件事，只能用户自定义加锁处理，即Lock

过程分析：所有线程抢的是GIL锁，或者说所有线程抢的是执行权限

　　线程1抢到GIL锁，拿到执行权限，开始执行，然后加了一把Lock，还没有执行完毕，即线程1还未释放Lock，有可能线程2抢到GIL锁，开始执行，执行过程中发现Lock还没有被线程1释放，于是线程2进入阻塞，被夺走执行权限，有可能线程1拿到GIL，然后正常执行到释放Lock。。。这就导致了串行运行的效果

　　既然是串行，那我们执行

　　t1.start()

　　t1.join

　　t2.start()

　　t2.join()

　　这也是串行执行啊，为何还要加Lock呢，需知join是等待t1所有的代码执行完，相当于锁住了t1的所有代码，而Lock只是锁住一部分操作共享数据的代码。

因为Python解释器帮你自动定期进行内存回收，你可以理解为python解释器里有一个独立的线程，每过一段时间它起wake up做一次全局轮询看看哪些内存数据是可以被清空的，此时你自己的程序里的线程和 py解释器自己的线程是并发运行的，假设你的线程删除了一个变量，py解释器的垃圾回收线程在清空这个变量的过程中的clearing时刻，可能一个其它线程正好又重新给这个还没来及得清空的内存空间赋值了，结果就有可能新赋值的数据被删除了，为了解决类似的问题，python解释器简单粗暴的加了锁，即当一个线程运行时，其它人都不能动，这样就解决了上述的问题，这可以说是Python早期版本的遗留问题。　

from threading import Threadimport os,timedef work():   global n   temp=n   time.sleep(0.1)   n=temp-1if __name__ == '__main__':   n=100   l=[]   for i in range(100):       p=Thread(target=work)       l.append(p)       p.start()   for p in l:       p.join()   print(n) #结果可能为99

锁通常被用来实现对共享资源的同步访问。为每一个共享资源创建一个Lock对象，当你需要访问该资源时，调用acquire方法来获取锁对象（如果其它线程已经获得了该锁，则当前线程需等待其被释放），待资源访问完后，再调用release方法释放锁：

import threadingR=threading.Lock()R.acquire()'''对公共数据的操作'''R.release()

from threading import Thread,Lockimport os,timedef work():   global n   lock.acquire()   temp=n   time.sleep(0.1)   n=temp-1   lock.release()if __name__ == '__main__':   lock=Lock()   n=100   l=[]   for i in range(100):       p=Thread(target=work)       l.append(p)       p.start()   for p in l:       p.join()

   print(n) #结果肯定为0，由原来的并发执行变成串行，牺牲了执行效率保证了数据安全

GIL锁与互斥锁综合分析（重点！！！）

分析：

　　1.100个线程去抢GIL锁，即抢执行权限

2. 肯定有一个线程先抢到GIL（暂且称为线程1），然后开始执行，一旦执行就会拿到lock.acquire()

3. 极有可能线程1还未运行完毕，就有另外一个线程2抢到GIL，然后开始运行，但线程2发现互斥锁lock还未被线程1释放，于是阻塞，被迫交出执行权限，即释放GIL

4.直到线程1重新抢到GIL，开始从上次暂停的位置继续执行，直到正常释放互斥锁lock，然后其他的线程再重复2 3 4的过程

互斥锁与join的区别（重点！！！）

#不加锁:并发执行,速度快,数据不安全from threading import current_thread,Thread,Lockimport os,timedef task():   global n   print('%s is running' %current_thread().getName())   temp=n   time.sleep(0.5)   n=temp-1

if __name__ == '__main__':   n=100   lock=Lock()   threads=[]   start_time=time.time()   for i in range(100):       t=Thread(target=task)       threads.append(t)       t.start()   for t in threads:       t.join()

   stop_time=time.time()   print('主:%s n:%s' %(stop_time-start_time,n))

'''Thread-1 is runningThread-2 is running......Thread-100 is running主:0.5216062068939209 n:99'''#不加锁:未加锁部分并发执行,加锁部分串行执行,速度慢,数据安全from threading import current_thread,Thread,Lockimport os,timedef task():   #未加锁的代码并发运行   time.sleep(3)   print('%s start to run' %current_thread().getName())   global n   #加锁的代码串行运行   lock.acquire()   temp=n   time.sleep(0.5)   n=temp-1   lock.release()

if __name__ == '__main__':   n=100   lock=Lock()   threads=[]   start_time=time.time()   for i in range(100):       t=Thread(target=task)       threads.append(t)       t.start()   for t in threads:       t.join()   stop_time=time.time()   print('主:%s n:%s' %(stop_time-start_time,n))

'''Thread-1 is runningThread-2 is running......Thread-100 is running主:53.294203758239746 n:0'''#有的同学可能有疑问:既然加锁会让运行变成串行,那么我在start之后立即使用join,就不用加锁了啊,也是串行的效果啊#没错:在start之后立刻使用jion,肯定会将100个任务的执行变成串行,毫无疑问,最终n的结果也肯定是0,是安全的,但问题是#start后立即join:任务内的所有代码都是串行执行的,而加锁,只是加锁的部分即修改共享数据的部分是串行的#单从保证数据安全方面,二者都可以实现,但很明显是加锁的效率更高.from threading import current_thread,Thread,Lockimport os,timedef task():   time.sleep(3)   print('%s start to run' %current_thread().getName())   global n   temp=n   time.sleep(0.5)   n=temp-1

if __name__ == '__main__':   n=100   lock=Lock()   start_time=time.time()   for i in range(100):       t=Thread(target=task)       t.start()       t.join()   stop_time=time.time()   print('主:%s n:%s' %(stop_time-start_time,n))

'''Thread-1 start to runThread-2 start to run......Thread-100 start to run主:350.6937336921692 n:0 #耗时是多么的恐怖'''

死锁现象与递归锁

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

from threading import Thread,Lockimport timemutexA=Lock()mutexB=Lock()class MyThread(Thread):   def run(self):       self.func1()       self.func2()   def func1(self):       mutexA.acquire()       print('\033[41m%s 拿到A锁\033[0m' %self.name)

       mutexB.acquire()       print('\033[42m%s 拿到B锁\033[0m' %self.name)       mutexB.release()

       mutexA.release()

   def func2(self):       mutexB.acquire()       print('\033[43m%s 拿到B锁\033[0m' %self.name)       time.sleep(2)

       mutexA.acquire()       print('\033[44m%s 拿到A锁\033[0m' %self.name)       mutexA.release()

       mutexB.release()if __name__ == '__main__':   for i in range(10):       t=MyThread()       t.start()'''Thread-1 拿到A锁Thread-1 拿到B锁Thread-1 拿到B锁Thread-2 拿到A锁然后就卡住，死锁了'''

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

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

mutexA=mutexB=threading.RLock() #一个线程拿到锁，counter加1,该线程内又碰到加锁的情况，则counter继续加1，这期间所有其他线程都只能等待，等待该线程释放所有锁，即counter递减到0为止

信号量Semaphore

同进程的一样

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

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

from threading import Thread,Semaphoreimport threadingimport time# def func():#     if sm.acquire():#         print (threading.currentThread().getName() + ' get semaphore')#         time.sleep(2)#         sm.release()def func():   sm.acquire()   print('%s get sm' %threading.current_thread().getName())   time.sleep(3)   sm.release()if __name__ == '__main__':   sm=Semaphore(5)   for i in range(23):       t=Thread(target=func)       t.start()

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。

例如，有多个工作线程尝试链接MySQL，我们想要在链接前确保MySQL服务正常才让那些工作线程去连接MySQL服务器，如果连接不成功，都会去尝试重新连接。那么我们就可以采用threading.Event机制来协调各个工作线程的连接操作.

from threading import Thread,Eventimport threadingimport time,randomdef conn_mysql():   count=1   while not event.is_set():       if count > 3:           raise TimeoutError('链接超时')       print('<%s>第%s次尝试链接' % (threading.current_thread().getName(), count))       event.wait(0.5)       count+=1   print('<%s>链接成功' %threading.current_thread().getName())def check_mysql():   print('\033[45m[%s]正在检查mysql\033[0m' % threading.current_thread().getName())   time.sleep(random.randint(2,4))   event.set()if __name__ == '__main__':   event=Event()   conn1=Thread(target=conn_mysql)   conn2=Thread(target=conn_mysql)   check=Thread(target=check_mysql)   conn1.start()   conn2.start()   check.start()

条件Condition（了解）

使得线程等待，只有满足某条件时，才释放n个线程

import threading

def run(n):   con.acquire()   con.wait()   print("run the thread: %s" %n)   con.release()

if __name__ == '__main__':

   con = threading.Condition()   for i in range(10):       t = threading.Thread(target=run, args=(i,))       t.start()   while True:       inp = input('>>>')       if inp == 'q':           break       con.acquire()       con.notify(int(inp))       con.release()

定时器

定时器，指定n秒后执行某操作

from threading import Timerdef hello():   print("hello, world")

t = Timer(1, hello)t.start()  # after 1 seconds, "hello, world" will be printed

线程queue

queue队列：使用import queue

import queueq=queue.Queue()q.put('first')q.put('second')q.put('third')print(q.get())print(q.get())print(q.get())'''结果(先进先出):firstsecondthird'''

识别图中二维码,欢迎关注python宝典