线程知识点(锁，信号量，队列，条件)

1线程锁

1.1GIL

1.2线程之间的数据安全问题

例如：多个线程对同一块数据进行操作；
        比如赋值运算， 一个线程那到数据还没有返回数据结果时间片轮转，引起数据的不安全；
    pop, append 操作是安全的，
    队列也是安全的

具体操作

`此处输入代码
from threading import Thread, Lock`
lock.acquire()
'''
    对数据的操作
'''
lock.release()

1.3递归锁和死锁现象

死锁

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

死锁现象

    两把锁
    异步的                                                                  
    操作的时候 抢到一把锁之后还要再去抢第二把锁
    一个线程抢到一把锁
    另一个线程抢到了另一把锁

解决办法

解决方法，递归锁，在Python中为了支持在同一线程中多次请求同一资源，python提供了可重入锁RLock。这个RLock内部维护着一个Lock和一个counter变量，counter记录了acquire的次数，从而使得资源可以被多次require。直到一个线程所有的acquire都被release，其他的线程才能获得资源。上面的例子如果使用RLock代替Lock，则不会发生死锁：

示例代码

import time                                  
def fun(lock):                               
    lock.acquire()                           
    print('我还活着')                            
    lock.release()                           
    time.sleep(1)                            
    lock.acquire()                           
    print('你还没死')                            
    lock.release()                           
def func(lock):                              
    lock.acquire()                           
    lock.acquire()                           
    print('没死')                              
    lock.release()                           
    lock.release()                           


if __name__ == '__main__':                   
    lock = Lock()                            
    # for i in range(10):                    
    t1 = Thread(target=fun, args=(lock,))    
    t1.start()                               
    t2 = Thread(target=func, args=(lock,))   
    t2.start()      

递归锁

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

具体代码

from threading import Thread, RLock         
fork_lock = noodle_lock = RLock()# 一把锁      
def fun1(*args):                            
    noodle_lock.acquire()                   
    #具体操作                                   
    fork_lock.acquire()                     
    # 具体操作                                  
    fork_lock.release()                     
    noodle_lock.release()  #只有当锁释放后才能执行其他操作

递归锁可以解决互斥锁的死锁问题

# 互斥锁
 ¦   # 两把锁
 ¦   # 多个线程抢
 # 递归锁
 ¦   # 一把锁
 ¦   # 多个线程抢

递归锁能够快速的解决死锁问题

  # 递归锁好不好？
  不好， 出现死锁，肯定是程序的逻辑有问题， 在快速解决死锁的情况下， 修改程序的逻辑。
 递归锁
 迅速恢复服务 递归锁替换互斥锁
     在接下来的时间中慢慢把递归锁替换成互斥锁
     能够完善代码的逻辑
     提高代码的效率
多个线程之间，用完一个资源再用另外一个资源
先释放一个资源，再去获取一个资源的锁

信号量

与进程的的信号量用法一样

事件Event

wait() 等待 事件内的信号编程True
set()  把信号变成True
clear  把信号变成False
is_set 查看信号状态是否为True

示例代码

from threading import
import time          

def fun1(e):         
    e.wait()   #在set没有调用之前下面的语句不执行 
    print('你好呀，我来了') 
def fun2(e):         
    time.sleep(5)    
    e.set()          

if __name__ == '__mai
    e = Event()      
    t1 = Thread(targe
    t1.start()       
    t2 = Thread(targe
    t2.start()       

条件 Condition

Python提供的Condition对象提供了对复杂线程同步问题的支持。Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。不断的重复这一过程，从而解决复杂的同步问题
from threading import Condition, Thread                                         
def fun(con, name):                                                              
    print('欢迎光临')                                                           
    con.acquire()                                                                
    con.wait()     #使用前后都需要加锁                                           
    print('%s go to school'%name)                                                
    con.release()                                                           
if __name__ == '__main__':                                                    
    con = Condition()                                                                  
    for i in range(10):                                                                
        t = Thread(target=fun, args=(con, i))                                          
        t.start()                                                                      
    con.acquire()                                                                      
    # con.notify(4)   #使用前后都需要加锁  每次默认一个，参数代表通过的次数                                     
    # con.notify_all()                                                                 
    con.notifyAll()                                                                    
    con.release()       

定时器 Timer

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

from threading import Thread, Timer                       
def func():                                               
    print('Timer: going to ')                             
if __name__ == '__main__':                                
    t = Timer(5, func)                                    
    t.start()                                   

线程队列 queue队列

跟队列进程队列一样的用法

q = queue.Queue()         
q.put(1)                  
q.put(2)                  
q.put(3)                  
#先进先出原则                   
print(q.get())    #1      
print(q.get())    #2      
print(q.get())    #3      

线程队列 LifoQueue

和栈类似先进后出

from queue import LifoQueue
q = LifoQueue()
q.put(1)
q.put(2)
q.put(3)
print(q.get()) #3
print(q.get()) #2
print(q.get()) #1

PriorityQueue

存储数据时可设置优先级的队列

from queue import PriorityQueue
q = PriorityQueue()
q.put((3,'lei'))
q.put((2,'wen'))
q.put((1,'xuan'))
print(q.get())
print(q.get())
print(q.get())