day42 Pyhton 并发编程05
一.内容回顾
# 线程 # 正常的编程界: # 进程 # 计算机中最小的资源分配单位 # 数据隔离 # 进程可以独立存在 # 创建与销毁 还有切换 都慢 给操作系统压力大 # 线程 # 计算机中能被CPU调度的最小单位 # 同一个进程中的多个线程资源共享 # 线程必须依赖进程存在 # 创建与销毁 还有切换 都比进程快很多 # Cpython解释器下 # GIL 全局解释器锁 # 保证了同一时刻下只有一个线程可以被CPU操作 # threading模块 # 创建子线程 Thread类 # start 开启子线程 # join 阻塞等待子线程结束 # setDeamon 设置守护线程 # 会等待主线程结束(包含所有非守护的子线程)之后守护线程才结束 # currentthread,enumerate,activecount # 查看当前线程,所有的线程对象组成的列表,列表的长度
# from threading import Thread,currentThread # def func(): # print(currentThread()) # for i in range(10): # Thread(target=func).start()
今日内容
# 1.锁 **** # 互斥锁 # 死锁现象 # 递归锁 # 2.其他模型 ** # 信号量 # 事件 # 条件 # 定时器 # 3.线程队列 **** # 4.线程池模块 ****
# 锁是用来做什么的? # 保证数据的安全的
# GIL是干什么的? # 全局解释器锁线程
# 有了GIL还要锁干啥?
# 有了GIL还是会出现数据不安全的现象,所以还是要用锁
# import time # from threading import Thread,Lock # n = 100 # def func(lock): # global n # # n -= 1 # with lock: # tmp = n-1 # n-=1 # time.sleep(0.1) # n = tmp # # if __name__ == '__main__': # l = [] # lock = Lock() # for i in range(100): # t = Thread(target=func,args=(lock,)) # t.start() # l.append(t) # for t in l:t.join() # print(n)
dis模块使用
import dis
n = 1
def func():
n = 100
n -= 1
dis.dis(func)
# 会出现线程不安全的两个条件
# 1.是全局变量
# 2.出现 += -=这样的操作
# 列表 字典
# 方法 l.append l.pop l.insert dic.update 都是线程安全的
# l[0] += 1
# d[k] += 1
死锁现象
# 科学家吃面问题 import time from threading import Thread,Lock # noodle_lock = Lock() # fork_lock = Lock() # 死锁不是时刻发生的,有偶然的情况整个程序都崩了 # 每一个线程之中不止一把锁,并且套着使用 # 如果某一件事情需要两个资源同时出现,那么不应该将这两个资源通过两把锁控制 # 而应看做一个资源
import time from threading import Thread,Lock noodle_lock = Lock() fork_lock = Lock( def eat1(name): noodle_lock.acquire() print('%s拿到面条了'%name) fork_lock.acquire() print('%s拿到叉子了'%name) print('%s开始吃面'%name) time.sleep(0.2) 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.2) noodle_lock.release() print('%s放下面了' % name) fork_lock.release() print('%s放下叉子了' % name) Thread(target=eat1,args=('alex',)).start() Thread(target=eat2,args=('wusir',)).start() Thread(target=eat1,args=('太白',)).start() Thread(target=eat2,args=('宝元',)).start() alex拿到面条了 alex拿到叉子了 alex开始吃面 alex放下叉子了wusir拿到叉子了 alex放下面了太白拿到面条了
发生了死锁
import time from threading import Thread,Lock lock = Lock() def eat1(name): lock.acquire()#只有一个锁,把资源都锁在一起 print('%s拿到面条了'%name) print('%s拿到叉子了'%name) print('%s开始吃面'%name) time.sleep(0.2) lock.release() print('%s放下叉子了' % name) print('%s放下面了' % name) def eat2(name): lock.acquire() print('%s拿到叉子了' % name) print('%s拿到面条了' % name) print('%s开始吃面' % name) time.sleep(0.2) lock.release() print('%s放下面了' % name) print('%s放下叉子了' % name) Thread(target=eat1,args=('alex',)).start() Thread(target=eat2,args=('wusir',)).start() Thread(target=eat1,args=('太白',)).start() Thread(target=eat2,args=('宝元',)).start()
# 先临时解决
# 然后再找到死锁的原因,再去修改
from threading import RLock,Lock,Thread
# 互斥锁 # 无论在相同的线程还是不同的线程,都只能连续acquire一次 # 要想再acquire,必须先release # 递归锁 # 在同一个线程中,可以无限次的acquire # 但是要想在其他线程中也acquire, # 必须现在自己的线程中添加和acquire次数相同的release
rlock = RLock() rlock.acquire() rlock.acquire() rlock.acquire() rlock.acquire() print('锁不住')
锁不住
lock = Lock() lock.acquire() print('1') lock.acquire() print('2')#不能打印2
rlock = RLock() def func(num): rlock.acquire() print('aaaa',num) rlock.acquire() print('bbbb',num) rlock.release() rlock.release() Thread(target=func,args=(1,)).start() Thread(target=func,args=(2,)).start() aaaa 1 bbbb 1 aaaa 2 bbbb 2
import time noodle_lock = fork_lock = RLock() def eat1(name): noodle_lock.acquire() print('%s拿到面条了'%name) fork_lock.acquire() print('%s拿到叉子了'%name) print('%s开始吃面'%name) time.sleep(0.2) 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.2) noodle_lock.release() print('%s放下面了' % name) fork_lock.release() print('%s放下叉子了' % name) Thread(target=eat1,args=('alex',)).start() Thread(target=eat2,args=('wusir',)).start() Thread(target=eat1,args=('太白',)).start() Thread(target=eat2,args=('宝元',)).start()
alex拿到面条了
alex拿到叉子了
alex开始吃面
alex放下叉子了
alex放下面了
wusir拿到叉子了
wusir拿到面条了
wusir开始吃面
wusir放下面了
wusir放下叉子了
太白拿到面条了
太白拿到叉子了
太白开始吃面
太白放下叉子了
太白放下面了
宝元拿到叉子了
宝元拿到面条了
宝元开始吃面
宝元放下面了
宝元放下叉子了
信号量
import time from threading import Semaphore,Thread def func(name,sem): sem.acquire() print(name,'start') time.sleep(1) print(name,'stop') sem.release() sem = Semaphore(5) for i in range(20): Thread(target=func,args=(i,sem)).start()
# 信号量和池 # 进程池 # 有1000个任务 # 一个进程池中有5个进程 # 所有的1000个任务会多次利用这五个进程来完成任务 # 信号量 # 有1000个任务 # 有1000个进程/线程 # 所有的1000个任务由于信号量的控制,只能5个5个的执行
事件
from threading import Event # 事件 # wait() 阻塞 到事件内部标识为True就停止阻塞 # 控制标识 # set # clear # is_set # 连接数据库 import time import random from threading import Thread,Event def connect_sql(e): count = 0 while count < 3: e.wait(0.5) if e.is_set(): print('连接数据库成功') break else: print('数据库未连接成功') count += 1 def test(e): time.sleep(random.randint(0,3)) e.set() e = Event() Thread(target=test,args=(e,)).start() Thread(target=connect_sql,args=(e,)).start()
条件
# wait 阻塞 # notify(n) 给信号 # 假如现在有20个线程 # 所有的线程都在wait这里阻塞 # notify(n) n传了多少 # 那么wait这边就能获得多少个解除阻塞的通知 # notifyall # acquire # release 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('****') # 设置某个条件 # 如果满足这个条件 就可以释放线程 # 监控测试我的网速 # 20000个任务 # 测试我的网速 /系统资源 # 发现系统资源有空闲,我就放行一部分任务
定时器
from threading import Timer def func(): print('执行我啦') t = Timer(3,func) # 现在这个时间点我不想让它执行,而是预估一下大概多久之后它执行比较合适 t.start() print('主线程的逻辑')
队列
import queue # 线程队列 线程之间数据安全 q = queue.Queue(1) # 普通队列 q.put(1) print(q.get()) try: q.put_nowait(2) except queue.Full: print('您丢失了一个数据2') print(q.get_nowait()) # 如果有数据我就取,如果没数据不阻塞而是报错 # 非阻塞的情况下 q.put(10) print(q.get(timeout=2)) 1 2 10
# 算法里 栈 lfq = queue.LifoQueue() # 栈 lfq.put(1) lfq.put(2) lfq.put(3) print(lfq.get()) print(lfq.get()) print(lfq.get()) 3 2 1
# 优先级队列,是根据第一个值的大小来排定优先级的 # ascii码越小,优先级越高 q = queue.PriorityQueue() q.put((2,'a')) q.put((0,'c')) q.put((1,'b')) print(q.get()) # 线程+队列 实现生产者消费者模型
线程池
def func(num): print('in %s func'%num,currentThread()) time.sleep(random.random()) return num**2 tp = ThreadPoolExecutor(5) ret_l = [] for i in range(30): ret = tp.submit(func,i)#运行时只有5个线程运行 ret_l.append(ret) for ret in ret_l: print(ret.result())
import time import random from threading import currentThread from concurrent.futures import ThreadPoolExecutor as Pool import os def func(num): print('in %s func'%num,currentThread()) # print('in %s func'%num,os.getpid()) time.sleep(random.random()) return num**2 if __name__ == '__main__': # tp = ThreadPoolExecutor(5) tp = Pool(5) ret_l = [] for i in range(30): ret = tp.submit(func,i) ret_l.append(ret) tp.shutdown() # close + join for ret in ret_l: print(ret.result())
# 创建一个池 # 提交任务 submit # 阻塞直到任务完成(close + join) shutdown # 获取结果 result # 简便用法 map # 回调函数 add_done_callback
# 简便用法 map import os def func(num): print('in %s func'%num,currentThread()) # print('in %s func'%num,os.getpid()) time.sleep(random.random()) return num**2 if __name__ == '__main__': # tp = ThreadPoolExecutor(5) tp = Pool(5) ret = tp.map(func,range(30)) for i in ret: print(i)
# 回调函数 add_done_callback def func1(num): print('in func1 ',num,currentThread()) return num*'*' def func2(ret): print('--->',ret.result(),currentThread()) tp = Pool(5) print('主 : ',currentThread()) for i in range(10): tp.submit(func1,i).add_done_callback(func2) # 回调函数收到的参数是需要使用result()获取的 # 回调函数是由谁执行的? 主线程
# 相关概念 # 进程 # 线程 # GIL # 很多模型 # 进程 锁(递归锁 互斥锁)\池(cpu的1-2倍)\队列 # 线程 锁(递归锁 互斥锁)\池(cpu个数的5倍)\队列 其他模型
