##内容回顾
#1、什么是GIL 全局解释器锁,本质就是一把互斥锁,是加到解释器身上的,每一个python进程内都有这么一把锁 #2、有了GIL会对单进程下的多个线程造成什么样的影响 多线程要想执行,首先需要争抢GIL,对所有待执行的线程来说,GIL就相当于执行权限,同一时刻只有一个线程争抢成功,即单进程下的多个线程同一时刻只有一个在运行 意味着单进程下的多线程没有并行的效果,但是有并发的效果 ps:分散于不同进程内的线程不会去争抢同一把GIL,只有同一个进程的多个线程才争抢同一把GIL #3、为什么要有GIL python解释器的内存管理机制不是线程安全的 #4、GIL与自定义互斥锁的区别,多个线程争抢GIL与自定义互斥锁的过程分析 相同: 都是互斥锁 不同点: GIL是加到解释器上的,作用于全局 自定义互斥锁作用于局部 单进程内的所有线程都会去抢GIL 单进程内的只有一部分线程会去抢自定义的互斥锁 5、什么时候用python的多线程,什么时候用多进程,为什么? 单进程下的多个线程是无法并行,无法并行意味着不能利用多核优势 cpu干的计算的活,多个cpu意味提升了计算性能, cpu是无法做IO操作,多个cpu在IO操作面前毫无用处 当我们的程序是IO密集型的情况下,多核对性能的提升微不足道,此时可以使用python的多线程 当我们的程序是计算密集型的情况下,一定要用上多核优势,此时可以使用python的多进程 2、进程池与线程池 1、池的用途,为何要用它 池:装固定数目的东西,东西指的是进程或者线程,让机器在自己可承受的范围内去保证一个高效的工作
##自己如何直接使用Thread的话 如何完成回调案例
"""
#回调函数:直接使用add_done_callback方法直接调用就好
在线程池/进程池 每次提交任务 都会返回一个表示任务的对象 Future对象 Future对象具备一个绑定方法 add_done_callback 用于指定回调函数 add 意味着可以添加多个回调函数
#使用线程Thread 自定义一个回调函数 """ from threading import Thread import time # res = None def call_back(res): print("任务结果拿到了:%s" % res) def parser(res): print("任务结果拿到了:%s" % res) def task(callback): # global res print("run") time.sleep(1) # # return 100 res = 100 # 表示任务结果 callback(res) # 执行回调函数 并传入任务结果 t = Thread(target=task,args=(parser,)) t.start() # t.join() # print(res) print("over")
##线程队列
#1.Queue 先进先出队列 与多进程中的Queue使用方式完全相同,区别仅仅是不能被多进程共享。 from queue import Queue,LifoQueue,PriorityQueue # q = Queue() # # q.put("123") # q.put("456") # # print(q.get()) # print(q.get()) # # # print(q.get(block=True,timeout=3)) # q.task_done() # q.task_done() # q.join() # print("over") #2.LifoQueue 后进先出队列 该队列可以模拟堆栈,实现先进后出,后进先出 # 除顺序以外别的都一样 # lq = LifoQueue() # # lq.put("123") # lq.put("456") # # print(lq.get()) # print(lq.get()) #3.PriorityQueue 优先级队列 该队列可以为每个元素指定一个优先级,这个优先级可以是数字,字符串或其他类型,但是必须是可以比较大小的类型,取出数据时会按照从小到大的顺序取出 pq = PriorityQueue() # 数字优先级 pq.put((10,"a")) pq.put((11,"a")) pq.put((-11111,"a")) print(pq.get()) print(pq.get()) print(pq.get()) # 字符串优先级 pq.put(("b","a")) pq.put(("c","a")) pq.put(("a","a")) print(pq.get()) print(pq.get()) print(pq.get()) #优先级:对象比较 class A(object): def __init__(self,age): self.age = age # def __lt__(self, other): # return self.age < other.age # # def __gt__(self, other): # return self.age > other.age def __eq__(self, other): return self.age == other.age a1 = A(50) a2 = A(50) print(a1 == a2) # print(a1 is a1) # pq = PriorityQueue() # pq.put("a") # pq.put("A") # pq.put("C") # # # print(pq.get())
##线程事件Event
### 1、什么是事件 事件表示在某个时间发生了某个事情的通知信号,用于线程间协同工作。 因为不同线程之间是独立运行的状态不可预测,所以一个线程与另一个线程间的数据是不同步的,当一个线程需要利用另一个线程的状态来确定自己的下一步操作时,就必须保持线程间数据的同步,Event就可以实现线程间同步 ###2、 Event介绍 Event象包含一个可由线程设置的信号标志,它允许线程等待某些事件的发生。在 初始情况下,Event对象中的信号标志被设置为假。如果有线程等待一个Event对象, 而这个Event对象的标志为假,那么这个线程将会被一直阻塞直至该标志为真。一个线程如果将一个Event对象的信号标志设置为真,它将唤醒所有等待这个Event对象的线程。如果一个线程等待一个已经被设置为真的Event对象,那么它将忽略这个事件, 继续执行 ###3、可用方法: event.isSet():返回event的状态值; event.wait():将阻塞线程;知道event的状态为True event.set(): 设置event的状态值为True,所有阻塞池的线程激活进入就绪状态, 等待操作系统调度; event.clear():恢复event的状态值为False。 ###4、使用案例 #4-1 在链接mysql服务器前必须保证mysql已经启动,而启动需要花费一些时间,所以客户端不能立即发起链接 需要等待msyql启动完成后立即发起链接 from threading import Event,Thread import time boot = False def start(): global boot print("正正在启动服务器.....") time.sleep(5) print("服务器启动完成!") boot = True def connect(): while True: if boot: print("链接成功") break else: print("链接失败") time.sleep(1) Thread(target=start).start() Thread(target=connect).start() Thread(target=connect).start() #4-2使用Event改造后: “”“ from threading import Event,Thread import time e = Event() def start(): global boot print("正正在启动服务器.....") time.sleep(3) print("服务器启动完成!") e.set() def connect(): e.wait() print("链接成功") Thread(target=start).start() Thread(target=connect).start() Thread(target=connect).start() ”“” #4-3增加需求,每次尝试链接等待1秒,尝试次数为3次 “”“ from threading import Event,Thread import time e = Event() def start(): global boot print("正正在启动服务器.....") time.sleep(5) print("服务器启动完成!") e.set() def connect(): for i in range(1,4): print("第%s次尝试链接" % i) e.wait(1) if e.isSet(): print("链接成功") break else: print("第%s次链接失败" % i) else: print("服务器未启动!") Thread(target=start).start() Thread(target=connect).start() # Thread(target=connect).start() ”“”
##协程
###协程理论基础### ###1、什么是协程 协程:是单线程下的并发,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的。 ###2、如何能够实现并发呢 并发 = 切换任务+保存状态,只要找到一种方案,能够在两个任务之间切换执行并且保存状态,那就可以实现单线程并发 python中的生成器就具备这样一个特点,每次调用next都会回到生成器函数中执行代码,这意味着任务之间可以切换,并且是基于上一次运行的结果,这意味着生成器会自动保存执行状态! ###3、对比操作系统控制线程的切换,用户在单线程内控制协程的切换 1. python的线程属于内核级别的,即由操作系统控制调度(如单线程遇到io或执行时间过长就会被迫交出cpu执行权限,切换其他线程运行) 2. 单线程内开启协程,一旦遇到io,就会从应用程序级别(而非操作系统)控制切换,以此来提升效率(!!!非io操作的切换与效率无关) ###4、优缺点 #优点: 1. 协程的切换开销更小,属于程序级别的切换,操作系统完全感知不到,因而更加轻量级 2. 单线程内就可以实现并发的效果,最大限度地利用cpu #缺点: 1. 协程的本质是单线程下,无法利用多核,可以是一个程序开启多个进程,每个进程内开启多个线程,每个线程内开启协程 2. 协程指的是单个线程,因而一旦协程出现阻塞,将会阻塞整个线程 ###5、总结协程特点: 必须在只有一个单线程里实现并发 修改共享数据不需加锁 用户程序里自己保存多个控制流的上下文栈 附加:一个协程遇到IO操作自动切换到其它协程(如何实现检测IO,yield、greenlet都无法实现,就用到了gevent模块(select机制)) ###6、yiled实现并发效果 # 使用生成器来实现 单线 并发多个任务 import time def func1(): a = 1 for i in range(10000000): a += 1 print("a run") time.sleep(10) yield def func2(): res = func1() a = 1 for i in range(10000000): a += 1 print("b run") next(res) st = time.time() func2() print(time.time() - st) ### 单线程下串行执行两个计算任务 效率反而比并发高 因为并发需要切换和保存 # def func1(): # a = 1 # for i in range(10000000): # a += 1 # # # def func2(): # a = 1 # for i in range(10000000): # a += 1 # # # st = time.time() # func1() # func2() # print(time.time() - st) ###7、greentlet模块实现并发 “”“ 使用yield来切换是的代码结构非常混乱,如果十个任务需要切换呢,不敢想象!因此就有人专门对yield进行了封装,这便有了greenlet模块该模块简化了yield复杂的代码结构,实现了单线程下多任务并发,但是无论直接使用yield还是greenlet都不能检测IO操作,遇到IO时同样进入阻塞状态,所以此时的并发是没有任何意义的。 现在我们需要一种方案 即可检测IO 又能够实现单线程并发,于是gevent闪亮登场 ”“” def task1(name): print("%s task1 run1" % name) g2.switch(name) # 切换至任务2 print("task1 run2") g2.switch() # 切换至任务2 def task2(name): print("%s task2 run1" % name) g1.switch() # 切换至任务1 print("task2 run2") g1 = greenlet.greenlet(task1) g2 = greenlet.greenlet(task2) g1.switch("jerry") # 为任务传参数 ###8、Gevent 模块实现单线程并发 “”“ #8-1 Gevent模块的介绍 Gevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。 #8-2Gevent模块的用法 #用法 g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1,spawn括号内第一个参数是函数名,如eat,后面可以有多个参数,可以是位置实参或关键字实参,都是传给函数eat的 g2=gevent.spawn(func2) g1.join() #等待g1结束 g2.join() #等待g2结束 #或者上述两步合作一步:gevent.joinall([g1,g2]) g1.value#拿到func1的返回值 #8-3 Gevent模块默认不识别IO阻塞的如(time.sleep(3)),只能默认是识别自身的gevent.sleep(2),我们就引入了猴子补丁用法 import gevent def eat(name): print('%s eat 1' %name) gevent.sleep(2) print('%s eat 2' %name) def play(name): print('%s play 1' %name) gevent.sleep(1) print('%s play 2' %name) g1=gevent.spawn(eat,'egon') g2=gevent.spawn(play,name='egon') g1.join() g2.join() #或者gevent.joinall([g1,g2]) print('主') ###8-4 Gevent模块:猴子补丁,就可以识别IO阻塞,注意:猴子补丁语句只能放在文件开头,我们可以用threading.current_thread().getName()来查看每个g1和g2,查看的结果为DummyThread-n,即假线程 #总结 1.如果主线程结束了 协程任务也会立即结束。 2.monkey补丁的原理是把原始的阻塞方法替换为修改后的非阻塞方法,即偷梁换柱,来实现IO自动切换 必须在打补丁后再使用相应的功能,避免忘记,建议写在最上方 ##8-4 示例一 # gevent 不具备检测IO的能力 需要为它打补丁 打上补丁之后就能检测IO # 注意补丁一定打在最上面 必须保证导入模块前就打好补丁 from gevent import monkey;monkey.patch_all() import gevent from threading import current_thread import time def task1(): print(current_thread(),1) print("task1 run") # gevent.sleep(3) time.sleep(3) print("task1 over") def task2(): print(current_thread(),2) print("task2 run") print("task2 over") # spawn 用于创建一个协程任务 g1 = gevent.spawn(task1) g2 = gevent.spawn(task2) # 任务要执行,必须保证主线程没挂 因为所有协程任务都是主线在执行 ,必须调用join来等待协程任务 # g1.join() # g2.join() # 理论上等待执行时间最长的任务就行 , 但是不清楚谁的时间长 可以全部join gevent.joinall([g1,g2]) print("over") ##8-4 示例二 import gevent,sys from gevent import monkey # 导入monkey补丁 monkey.patch_all() # 打补丁 import time print(sys.path) def task1(): print("task1 run") # gevent.sleep(3) time.sleep(3) print("task1 over") def task2(): print("task2 run") # gevent.sleep(1) time.sleep(1) print("task2 over") g1 = gevent.spawn(task1) g2 = gevent.spawn(task2) #gevent.joinall([g1,g2]) g1.join() g2.join() # 执行以上代码会发现不会输出任何消息 # 这是因为协程任务都是以异步方式提交,所以主线程会继续往下执行,而一旦执行完最后一行主线程也就结束了, # 导致了协程任务没有来的及执行,所以这时候必须join来让主线程等待协程任务执行完毕 也就是让主线程保持存活 # 后续在使用协程时也需要保证主线程一直存活,如果主线程不会结束也就意味着不需要调用join ”“”