线程进阶

锁

为什么要有锁?

如果一个线程在执行过程中被打断了 另一个线程来取数据 取到的是没有被处理完的数据

　　

死锁

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

假设有甲乙丙在吃一碗意大利面 甲拿了面 再拿筷子 吃完换下一个人吃 那么可能甲放下意大利面 被等待面的乙拿了 而筷子被丙拿了 那么就成了死锁 两个人都吃不到面了,示例

吃面的死锁

互斥锁

from threading import Thread,Lock
n = 0
def func(lock):
    global n
    for i in range(150000):
        lock.acquire()
        n  -= 1
        lock.release()

def func2(lock):
    global n
    for i in range(150000):
        lock.acquire()
        n += 1
        lock.release()

if __name__ == '__main__':
    t_lst = []
    lock = Lock()
    for i in range(5):
        t2 = Thread(target=func2,args=(lock,))
        t = Thread(target=func,args=(lock,))
        t.start()
        t2.start()
        t_lst.append(t)
        t_lst.append(t2)
    for t in t_lst:
        t.join()
    print('-->',n)

递归锁

from threading import Thread,RLock
rlock = RLock()
def func(name):
    rlock.acquire()
    print(name,1)
    rlock.acquire()
    print(name,2)
    rlock.acquire()
    print(name,3)
    rlock.release()
    rlock.release()
    rlock.release()

for i in range(10):
    Thread(target=func,args=('name%s'%i,)).start()

import time
from threading import Thread,RLock

fork_lock = noodle_lock = RLock()
def eat1(name):
    noodle_lock.acquire()
    print('%s拿到面条了'%name)
    fork_lock.acquire()
    print('%s拿到叉子了'%name)
    print('%s吃面'%name)
    time.sleep(0.3)
    fork_lock.release()
    print('%s放下叉子'%name)
    noodle_lock.release()
    print('%s放下面'%name)

def eat2(name):
    fork_lock.acquire()
    print('%s拿到叉子了' % name)
    noodle_lock.acquire()
    print('%s拿到面条了'%name)
    print('%s吃面'%name)
    time.sleep(0.3)
    noodle_lock.release()
    print('%s放下面'%name)
    fork_lock.release()
    print('%s放下叉子' % name)

if __name__ == '__main__':
    name_list = ['甲','乙']
    name_list2 = ['丙','丁']
    for name in name_list:
        Thread(target=eat1,args=(name,)).start()
    for name in name_list2:
        Thread(target=eat2,args=(name,)).start()

递归锁吃面

信号量

同进程的一样

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

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

import time
from threading import Semaphore,Thread

def func(index,sem):
    sem.acquire()
    print(index)
    time.sleep(1)
    sem.release()

if __name__ == '__main__':
    sem = Semaphore(5)
    for i in range(10):
        Thread(target=func,args=(i,sem)).start()

事件

同进程的一样

线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用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机制来协调各个工作线程的连接操作

import time
import random
from threading import Event,Thread
def check(e):
    print('开始检测数据库连接')
    time.sleep(random.randint(1,5))  # 检测数据库连接
    e.set()  # 成功了

def connect(e):
    for i in range(3):
        e.wait(0.5)
        if e.is_set():
            print('数据库连接成功')
            break
        else:
            print('尝试连接数据库%s次失败'%(i+1))
    else:
        raise TimeoutError

e = Event()
Thread(target=connect,args=(e,)).start()
Thread(target=check,args=(e,)).start()

View Code

条件

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

Python提供的Condition对象提供了对复杂线程同步问题的支持。
Condition被称为条件变量，除了提供与Lock类似的acquire和release方法外
，还提供了wait和notify方法。线程首先acquire一个条件变量，然后判断一些条件。
如果条件不满足则wait；如果条件满足，进行一些处理改变条件后，
通过notify方法通知其他线程，其他处于wait状态的线程接到通知后会重新判断条件。
不断的重复这一过程，从而解决复杂的同步问题。

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()
        print('****')

View Code

定时器

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

from threading import Timer
 
def hello():
    print("hello, world")
 
t = Timer(1, hello)
t.start()  # after 1 seconds, "hello, world" will be printed

队列

queue队列 ：使用import 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())

栈

后进先出

import queue

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

print(q.get())
print(q.get())
print(q.get())

优先级队列

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')
'''

优先级队列