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('33[32m%s 拿到A锁' %self.name)
        mutexB.acquire()
        print('33[45m%s 拿到B锁' %self.name)
        mutexB.release()
        mutexA.release()

    def f2(self):
        mutexB.acquire()
        print('33[32m%s 拿到B锁' %self.name)
        time.sleep(1)
        mutexA.acquire()
        print('33[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('33[45m%s 等' %currentThread().getName())
    e.wait()
    print('33[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('33[45m%s 第%s次尝试' %(currentThread().getName(),count))
        e.wait(timeout=1)
        count+=1
    print('33[45m%s 开始链接' %currentThread().getName())

def check_mysql():
    print('33[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')
'''