python-day36--并发编程之多线程

十三、死锁、递归锁

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

 from threading import Lock,Thread
 import time
 mutexB=Lock()
 mutexA=Lock()
 class MyThread(Thread):
     def run(self):
         self.f1()
         self.f2()

     def f1(self):
         mutexA.acquire()
         print('%s拿到了A锁' %self.name)
         mutexB.acquire()
         print('%s拿到了B锁' %self.name)
         mutexB.release()
         mutexA.release()

     def f2(self):
         mutexB.acquire()
         print('%s拿到了B锁' %self.name)
         time.sleep(1)
         mutexA.acquire()
         print('%s拿到了A锁' %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锁
 。。。。 卡住了

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

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

 from threading import Thread,RLock
 import time
 mutexB=mutexA=RLock()
 class MyThread(Thread):
     def run(self):
         self.f1()
         self.f2()

     def f1(self):
         mutexA.acquire()
         print('\033[32m%s 拿到A锁' %self.name)
         mutexB.acquire()
         print('\033[45m%s 拿到B锁' %self.name)
         mutexB.release()
         mutexA.release()

     def f2(self):
         mutexB.acquire()
         print('\033[32m%s 拿到B锁' %self.name)
         time.sleep(1)
         mutexA.acquire()
         print('\033[45m%s 拿到A锁' %self.name)
         mutexA.release()
         mutexB.release()

 if __name__ == '__main__':
     for i in range(2):
         t=MyThread()
         t.start()

 # 结果：
 # Thread-1 拿到A锁
 # Thread-1 拿到B锁
 # Thread-1 拿到B锁
 # Thread-1 拿到A锁
 # Thread-2 拿到A锁
 # Thread-2 拿到B锁
 # Thread-2 拿到B锁
 # Thread-2 拿到A锁

十四、信号量Semaphore

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

 from threading import Thread,Semaphore,currentThread
 import time,random
 sm=Semaphore(5)    #限制最大连接数为5
 def task():
     sm.acquire()
     print('%s 上厕所' %currentThread().getName())
     time.sleep(random.randint(1,3))
     print('%s 走了' %currentThread().getName())
     sm.release()
 if __name__ == '__main__':
     for i in range(20):
         t=Thread(target=task)
         t.start()

　　与进程池是完全不同的概念，进程池Pool(4)，最大只能产生4个进程，而且从头到尾都只是这　　　　四个进程，不会产生新的，而信号量是产生一堆线程/进程

十五、Event事件

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

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

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

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

 from threading import Thread,Event,currentThread
 import time
 e=Event()

 def traffic_lights():
     time.sleep(5)
     e.set()

 def car():
     print('\033[45m%s 等' %currentThread().getName())
     e.wait()
     print('\033[45m%s 跑' %currentThread().getName())

 if __name__ == '__main__':
     for i in range(10):
         t=Thread(target=car)
         t.start()
     traffic_thread=Thread(target=traffic_lights)
     traffic_thread.start()

例子

 from threading import Thread,Event,currentThread
 import time
 e=Event()
 def conn_mysql():
     count=1
     while not e.is_set():
         if count > 3:
             raise ConnectionError('尝试链接的次数过多')
         print('\033[45m%s 第%s次尝试' %(currentThread().getName(),count))
         e.wait(timeout=1)
         count+=1
     print('\033[45m%s 开始链接' %currentThread().getName())

 def check_mysql():
     print('\033[45m%s 检测mysql...' %currentThread().getName())
     time.sleep(4)     #超时了
     e.set()
 if __name__ == '__main__':
     t=Thread(target=check_mysql)
     t.start()
     for i in range(3):
         t=Thread(target=conn_mysql)
         t.start()

重要的例子

十六、定时器

 from threading import Timer

 def hello(n):
     print("hello, world",n)

 t = Timer(3, hello,args=(123,))   #3秒后运行hello函数， 可以传参数
 t.start()

十七、线程queue

　　queue队列 ：使用import queue，用法与进程Queue一样

　　queue.Queue      #先进先出   #队列

 import queue

 q=queue.Queue()
 q.put('first')
 q.put('second')
 q.put('third')

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(先进先出):
 first
 second
 third
 '''

　　queue.LifoQueue     #last in fisrt out  #堆栈

 import queue

 q=queue.LifoQueue()
 q.put('first')
 q.put('second')
 q.put('third')

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(后进先出):
 third
 second
 first
 '''

　　queue.PriorityQueue     #存储数据时可设置优先级的队列

 import queue

 q=queue.PriorityQueue()
 #put进入一个元组,元组的第一个元素是优先级(通常是数字,也可以是非数字之间的比较),数字越小优先级越高
 q.put((20,'a'))
 q.put((10,'b'))
 q.put((30,'c'))

 print(q.get())
 print(q.get())
 print(q.get())
 '''
 结果(数字越小优先级越高,优先级高的优先出队):
 (10, 'b')
 (20, 'a')
 (30, 'c')
 '''