python学习点滴记录-Day10-线程
多线程
协程
io模型
并发编程需要掌握的点:
1 生产者消费者模型2 进程池线程池3 回调函数4 GIL全局解释器锁
线程
理论部分
(摘自egon老师博客)
一、定义:
在传统操作系统中,每个进程有一个地址空间,而且默认就有一个控制线程
线程顾名思义,就是一条流水线工作的过程,一条流水线必须属于一个车间,一个车间的工作过程是一个进程
车间负责把资源整合到一起,是一个资源单位,而一个车间内至少有一个流水线
流水线的工作需要电源,电源就相当于cpu
所以,进程只是用来把资源集中到一起(进程只是一个资源单位,或者说资源集合),而线程才是cpu上的执行单位。
多线程(即多个控制线程)的概念是,在一个进程中存在多个控制线程,多个控制线程共享该进程的地址空间,相当于一个车间内有多条流水线,都共用一个车间的资源。
例如,北京地铁与上海地铁是不同的进程,而北京地铁里的13号线是一个线程,北京地铁所有的线路共享北京地铁所有的资源,比如所有的乘客可以被所有线路拉。
二、线程进程性能开销对比:
创建进程的开销要远大于线程?
如果我们的软件是一个工厂,该工厂有多条流水线,流水线工作需要电源,电源只有一个即cpu(单核cpu)
一个车间就是一个进程,一个车间至少一条流水线(一个进程至少一个线程)
创建一个进程,就是创建一个车间(申请空间,在该空间内建至少一条流水线)
而建线程,就只是在一个车间内造一条流水线,无需申请空间,所以创建开销小
进程之间是竞争关系,线程之间是协作关系?
车间直接是竞争/抢电源的关系,竞争(不同的进程直接是竞争关系,是不同的程序员写的程序运行的,迅雷抢占其他进程的网速,360把其他进程当做病毒干死)
一个车间的不同流水线式协同工作的关系(同一个进程的线程之间是合作关系,是同一个程序写的程序内开启动,迅雷内的线程是合作关系,不会自己干自己)三、线程与进程的区别
1、线程之间共享着同一进程的内存空间,而进程之间是隔离的,有各自的内存空间。
2、同一进程中的多个线程之间可以直接通讯,而进程之间通讯是需要ipc介质,如队列,管道。
3、新的线程就是简单的直接创建,而新进程需要拷贝父进程的地址空间所以要慢。
四、为何要用多线程
多线程指的是,在一个进程中开启多个线程,简单的讲:如果多个任务共用一块地址空间,那么必须在一个进程内开启多个线程。详细的讲分为4点:
1. 多线程共享一个进程的地址空间
2. 线程比进程更轻量级,线程比进程更容易创建可撤销,在许多操作系统中,创建一个线程比创建一个进程要快10-100倍,在有大量线程需要动态和快速修改时,这一特性很有用
3. 若多个线程都是cpu密集型的,那么并不能获得性能上的增强,但是如果存在大量的计算和大量的I/O处理,拥有多个线程允许这些活动彼此重叠运行,从而会加快程序执行的速度。
4. 在多cpu系统中,为了最大限度的利用多核,可以开启多个线程,比开进程开销要小的多。(这一条并不适用于python)
五、应用举例
开启一个字处理软件进程,该进程肯定需要办不止一件事情,比如监听键盘输入,处理文字,定时自动将文字保存到硬盘,这三个任务操作的都是同一块数据,因而不能用多进程。只能在一个进程里并发地开启三个线程,如果是单线程,那就只能是,键盘输入时,不能处理文字和自动保存,自动保存时又不能输入和处理文字。
开启多线程
主线程从执行层面就代表了其所在进程的执行过程
1 开启线程的两种方式View Code2 线程与进程的pidView Code3 多线程共享同一个进程内的资源证明进程之间隔离,而线程共享着进程的内存空间数据4 多线程共享同一进程内地址空间的小练习View Code5 Thread对象其他相关的属性或方法Thread实例对象的方法# isAlive(): 返回线程是否活动的。# getName(): 返回线程名。# setName(): 设置线程名。threading模块提供的一些方法:# threading.currentThread(): 返回当前的线程变量。# threading.enumerate(): 返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。# threading.activeCount(): 返回正在运行的线程数量,与len(threading.enumerate())有相同的结果。
守护线程
理论:
无论是进程还是线程,都遵循:守护xxx会等待主xxx运行完毕后被销毁
需要强调的是:运行完毕并非终止运行
#1.对主进程来说,运行完毕指的是主进程代码运行完毕#2.对主线程来说,运行完毕指的是主线程所在的进程内所有非守护线程统统运行完毕,主线程才算运行完毕详细解释:
#1 主进程在其代码结束后就已经算运行完毕了(守护进程在此时就被回收),然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程),才会结束,#2 主线程在其他非守护线程运行完毕后才算运行完毕(守护线程在此时就被回收)。因为主线程的结束意味着进程的结束,进程整体的资源都将被回收,而进程必须保证非守护线程都运行完毕后才能结束。from threading import Thread import time def sayhi(name):time.sleep(2)print('%s say hello' %name)if __name__ == '__main__':t=Thread(target=sayhi,args=('egon',))t.setDaemon(True) #必须在t.start()之前设置t.start()print('主线程')print(t.is_alive())'''主线程True'''1 from threading import Thread 2 import time 3 def foo(): 4 print(123) 5 time.sleep(1) 6 print("end123") 7 8 def bar(): 9 print(456) 10 time.sleep(3) 11 print("end456") 12 13 14 t1=Thread(target=foo) 15 t2=Thread(target=bar) 16 17 t1.daemon=True 18 t1.start() 19 t2.start() 20 print("main-------") 21 22 迷惑人的例子容易迷惑的点
python的GIL(Global Interpreter Lock)
在Cpython解释器中,同一个进程下开启的多线程,同一时刻只能有一个线程执行,无法利用多核优势GIL本质就是一把互斥锁,既然是互斥锁,所有互斥锁的本质都一样,都是将并发运行变成串行,以此来控制同一时间内共享数据只能被一个任务所修改,进而保证数据安全。
可以肯定的一点是:保护不同的数据的安全,就应该加不同的锁。
要想了解GIL,首先确定一点:每次执行python程序,都会产生一个独立的进程。例如python test.py,python aaa.py,python bbb.py会产生3个不同的python进程
''' #验证python test.py只会产生一个进程 #test.py内容 import os,time print(os.getpid()) time.sleep(1000) ''' python3 test.py #在windows下 tasklist |findstr python #在linux下 ps aux |grep python在一个python的进程内,不仅有test.py的主线程或者由该主线程开启的其他线程,还有解释器开启的垃圾回收等解释器级别的线程,总之,所有线程都运行在这一个进程内,毫无疑问
#1 所有数据都是共享的,这其中,代码作为一种数据也是被所有线程共享的(test.py的所有代码以及Cpython解释器的所有代码) 例如:test.py定义一个函数work(代码内容如下图),在进程内所有线程都能访问到work的代码,于是我们可以开启三个线程然后target都指向该代码,能访问到意味着就是可以执行。#2 所有线程的任务,都需要将任务的代码当做参数传给解释器的代码去执行,即所有的线程要想运行自己的任务,首先需要解决的是能够访问到解释器的代码。综上:
如果多个线程的target=work,那么执行流程是
多个线程先访问到解释器的代码,即拿到执行权限,然后将target的代码交给解释器的代码去执行
解释器的代码是所有线程共享的,所以垃圾回收线程也可能访问到解释器的代码而去执行,这就导致了一个问题:对于同一个数据100,可能线程1执行x=100的同时,而垃圾回收执行的是回收100的操作,解决这种问题没有什么高明的方法,就是加锁处理,如下图的GIL,保证python解释器同一时间只能执行一个任务的代码
GIL和Lock
GIL保护的是解释器级的数据,保护用户自己的数据则需要自己加锁处理,如下图
GIL和多线程
有了GIL的存在,同一时刻同一进程中只有一个线程被执行
听到这里,有的同学立马质问:进程可以利用多核,但是开销大,而python的多线程开销小,但却无法利用多核优势,也就是说python没用了,php才是最牛逼的语言?
别着急啊,老娘还没讲完呢。
要解决这个问题,我们需要在几个点上达成一致:
#1. cpu到底是用来做计算的,还是用来做I/O的?#2. 多cpu,意味着可以有多个核并行完成计算,所以多核提升的是计算性能#3. 每个cpu一旦遇到I/O阻塞,仍然需要等待,所以多核对I/O操作没什么用处一个工人相当于cpu,此时计算相当于工人在干活,I/O阻塞相当于为工人干活提供所需原材料的过程,工人干活的过程中如果没有原材料了,则工人干活的过程需要停止,直到等待原材料的到来。
如果你的工厂干的大多数任务都要有准备原材料的过程(I/O密集型),那么你有再多的工人,意义也不大,还不如一个人,在等材料的过程中让工人去干别的活,
反过来讲,如果你的工厂原材料都齐全,那当然是工人越多,效率越高
结论:
对计算来说,cpu越多越好,但是对于I/O来说,再多的cpu也没用
当然对运行一个程序来说,随着cpu的增多执行效率肯定会有所提高(不管提高幅度多大,总会有所提高),这是因为一个程序基本上不会是纯计算或者纯I/O,所以我们只能相对的去看一个程序到底是计算密集型还是I/O密集型,从而进一步分析python的多线程到底有无用武之地
#分析: 我们有四个任务需要处理,处理方式肯定是要玩出并发的效果,解决方案可以是: 方案一:开启四个进程 方案二:一个进程下,开启四个线程#单核情况下,分析结果: 如果四个任务是计算密集型,没有多核来并行计算,方案一徒增了创建进程的开销,方案二胜如果四个任务是I/O密集型,方案一创建进程的开销大,且进程的切换速度远不如线程,方案二胜#多核情况下,分析结果: 如果四个任务是计算密集型,多核意味着并行计算,在python中一个进程中同一时刻只有一个线程执行用不上多核,方案一胜如果四个任务是I/O密集型,再多的核也解决不了I/O问题,方案二胜#结论:现在的计算机基本上都是多核,python对于计算密集型的任务开多线程的效率并不能带来多大性能上的提升,甚至不如串行(没有大量切换),但是,对于IO密集型的任务效率还是有显著提升的。只有遇到io阻塞时,切换才能提升效率
#多进程: #优点:可以利用多核优势 #缺点:开销大 对于io密集型的程序,多进程会适得其反,这时候就该用多线程的方式。#多线程: #优点:开销小 #缺点:不能利用多核优势# from threading import Thread # from multiprocessing import Process # import time # #计算密集型 # def work(): # res=1 # for i in range(100000000): # res+=i # # if __name__ == '__main__': # p_l=[] # start=time.time() # for i in range(4): # # p=Process(target=work) #6.7473859786987305 # p=Thread(target=work) #24.466399431228638 # p_l.append(p) # p.start() # for p in p_l: # p.join() # # print(time.time()-start)from threading import Thread from multiprocessing import Process import time #IO密集型 def work():time.sleep(2)if __name__ == '__main__':p_l=[]start=time.time()for i in range(400):# p=Process(target=work) #12.104692220687866p=Thread(target=work) #2.038116455078125 p_l.append(p)p.start()for p in p_l:p.join()print(time.time()-start)from multiprocessing import Process from threading import Thread import os,time def work():res=0for i in range(100000000):res*=iif __name__ == '__main__':l=[]print(os.cpu_count()) #本机为4核start=time.time()for i in range(4):p=Process(target=work) #耗时5s多p=Thread(target=work) #耗时18s多 l.append(p)p.start()for p in l:p.join()stop=time.time()print('run time is %s' %(stop-start))计算密集型:多进程效率高
from multiprocessing import Process from threading import Thread import threading import os,time def work():time.sleep(2)print('===>')if __name__ == '__main__':l=[]print(os.cpu_count()) #本机为4核start=time.time()for i in range(400):# p=Process(target=work) #耗时12s多,大部分时间耗费在创建进程上p=Thread(target=work) #耗时2s多 l.append(p)p.start()for p in l:p.join()stop=time.time()print('run time is %s' %(stop-start))I/O密集型:多线程效率高
应用:
多线程用于IO密集型,如socket,爬虫,web
多进程用于计算密集型,如金融分析
死锁和递归锁
所谓死锁: 是指两个或两个以上的进程或线程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁,这些永远在互相等待的进程称为死锁进程,如下就是死锁
from threading import Thread,Lock import time mutexA=Lock() mutexB=Lock()class MyThread(Thread):def run(self):self.func1()self.func2()def func1(self):mutexA.acquire()print('\033[41m%s 拿到A锁\033[0m' %self.name)mutexB.acquire()print('\033[42m%s 拿到B锁\033[0m' %self.name)mutexB.release()mutexA.release()def func2(self):mutexB.acquire()print('\033[43m%s 拿到B锁\033[0m' %self.name)time.sleep(2)mutexA.acquire()print('\033[44m%s 拿到A锁\033[0m' %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锁 然后就卡住,死锁了 '''View Code
解决方法,递归锁,在Python中为了支持在同一线程中多次请求同一资源,python提供了可重入锁RLock。
这个RLock内部维护着一个Lock和一个counter变量,counter记录了acquire的次数,从而使得资源可以被多次require。直到一个线程所有的acquire都被release,其他的线程才能获得资源。上面的例子如果使用RLock代替Lock,则不会发生死锁:
mutexA=mutexB=threading.RLock() #一个线程拿到锁,counter加1,该线程内又碰到加锁的情况,则counter继续加1,这期间所有其他线程都只能等待,等待该线程释放所有锁,即counter递减到0为止
信号量
同进程的一样
Semaphore管理一个内置的计数器,
每当调用acquire()时内置计数器-1;
调用release() 时内置计数器+1;
计数器不能小于0;当计数器为0时,acquire()将阻塞线程直到其他线程调用release()。实例:(同时只有5个线程可以获得semaphore,即可以限制最大连接数为5):
from threading import Thread,Semaphore import threading import time # def func(): # if sm.acquire(): # print (threading.currentThread().getName() + ' get semaphore') # time.sleep(2) # sm.release() def func():sm.acquire()print('%s get sm' %threading.current_thread().getName())time.sleep(3)sm.release() if __name__ == '__main__':sm=Semaphore(5)for i in range(23):t=Thread(target=func)t.start()与进程池是完全不同的概念,进程池Pool(4),最大只能产生4个进程,而且从头到尾都只是这四个进程,不会产生新的,
而信号量是产生一堆线程/进程
事件event
同进程的一样
线程的一个关键特性是每个线程都是独立运行且状态不可预测。如果程序中的其 他线程需要通过判断某个线程的状态来确定自己下一步的操作,这时线程同步问题就会变得非常棘手。为了解决这些问题,我们需要使用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机制来协调各个工作线程的连接操作
from threading import Thread,Event import threading import time,random def conn_mysql():count=1while not event.is_set():if count > 3:raise TimeoutError('链接超时')print('<%s>第%s次尝试链接' % (threading.current_thread().getName(), count))event.wait(0.5)count+=1print('<%s>链接成功' %threading.current_thread().getName())def check_mysql():print('\033[45m[%s]正在检查mysql\033[0m' % threading.current_thread().getName())time.sleep(random.randint(2,4))event.set() if __name__ == '__main__':event=Event()conn1=Thread(target=conn_mysql)conn2=Thread(target=conn_mysql)check=Thread(target=check_mysql)conn1.start()conn2.start()check.start()View Code
定时器
定时器,指定n秒后执行某操作
from threading import Timerdef hello():print("hello, world")t = Timer(1, hello) t.start() # after 1 seconds, "hello, world" will be printed
线程queue
queue队列 :使用import queue,用法与进程Queue一样
queue is especially useful in threaded programming when information must be exchanged safely between multiple threads.
- class
queue.
Queue
(maxsize=0) #先进先出 队列class
queue.
LifoQueue
(maxsize=0) #last in fisrt out 堆栈class
queue.
PriorityQueue
(maxsize=0) #存储数据时可设置优先级的队列import queue# q=queue.Queue(3) #队列:先进先出 # q.put(1) # q.put(2) # q.put(3) # # print(q.get()) # print(q.get()) # print(q.get())# q=queue.LifoQueue(3) #堆栈:后进先出 # q.put(1) # q.put(2) # q.put(3) # # print(q.get()) # print(q.get()) # print(q.get()) q=queue.PriorityQueue(3) #数字越小优先级越高 q.put((10,'data1')) q.put((11,'data2')) q.put((9,'data3'))print(q.get()) print(q.get()) print(q.get())线程queue示例集合
Python标准模块--concurrent.futures(重点掌握,后期使用这个来实现并发处理任务)
concurrent.futures
进程池(ProcessPoolExecutor)
进程数默认为cpu核数
线程池(ThreadPoolExecutor)
线程数默认为cpu核数*5
三个方法:
submit
等同于Process的apply_async;通过result拿到进程池运行结果,相当于get,和submit连着使用相当于apply,还可以通过add_done_callback使用回调函数
shutdown
整合了close和join的功能
map
不需要回调函数的情况下使用map方法,可以拿到每次运行的结果。
简单应用示例:
#进程池 import requests #pip3 install requests import os,time from multiprocessing import Pool from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor def get_page(url):print('<%s> get :%s' %(os.getpid(),url))respone = requests.get(url)if respone.status_code == 200:return {'url':url,'text':respone.text}def parse_page(obj):dic=obj.result()print('<%s> parse :%s' %(os.getpid(),dic['url']))time.sleep(0.5)res='url:%s size:%s\n' %(dic['url'],len(dic['text'])) #模拟解析网页内容with open('db.txt','a') as f:f.write(res)if __name__ == '__main__':# p=Pool(4)p=ProcessPoolExecutor()urls = ['http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com',]for url in urls:# p.apply_async(get_page,args=(url,),callback=parse_page) p.submit(get_page,url).add_done_callback(parse_page)p.shutdown()print('主进程pid:',os.getpid())进程池
#线程池 import requests #pip3 install requests import os,time,threading from multiprocessing import Pool from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor def get_page(url):print('<%s> get :%s' %(threading.current_thread().getName(),url))respone = requests.get(url)if respone.status_code == 200:return {'url':url,'text':respone.text}def parse_page(obj):dic=obj.result()print('<%s> parse :%s' %(threading.current_thread().getName(),dic['url']))time.sleep(0.5)res='url:%s size:%s\n' %(dic['url'],len(dic['text'])) #模拟解析网页内容with open('db.txt','a') as f:f.write(res)if __name__ == '__main__':# p=Pool(4)p=ThreadPoolExecutor(3)urls = ['http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com','http://www.baidu.com',]for url in urls:# p.apply_async(get_page,args=(url,),callback=parse_page) p.submit(get_page,url).add_done_callback(parse_page)p.shutdown()print('主进程pid:',os.getpid())线程池
from concurrent.futures import ProcessPoolExecutor,ThreadPoolExecutor import os,time,random def work(n):print('%s is running' %os.getpid())time.sleep(random.randint(1,3))return n**2if __name__ == '__main__':p=ProcessPoolExecutor()# objs=[]# for i in range(10):# obj=p.submit(work,i)# objs.append(obj)# p.shutdown()# for obj in objs:# print(obj.result()) obj=p.map(work,range(10))p.shutdown()print(list(obj))map方法
协程
本节的主题是基于单线程来实现并发,即只用一个主线程(很明显可利用的cpu只有一个)情况下实现并发,为此我们需要先回顾下并发的本质:切换+保存状态
cpu正在运行一个任务,会在两种情况下切走去执行其他的任务(切换由操作系统强制控制),一种情况是该任务发生了阻塞,另外一种情况是该任务计算的时间过长
ps:在介绍进程理论时,提及进程的三种执行状态,而线程才是执行单位,所以也可以将上图理解为线程的三种状态
一:其中第二种情况并不能提升效率,只是为了让cpu能够雨露均沾,实现看起来所有任务都被“同时”执行的效果,如果多个任务都是纯计算的,这种切换反而会降低效率。
二:第一种情况的切换。在任务一遇到io情况下,切到任务二去执行,这样就可以利用任务一阻塞的时间完成任务二的计算,效率的提升就在于此。
对于单线程下,我们不可避免程序中出现io操作,但如果我们能在自己的程序中(即用户程序级别,而非操作系统级别)控制单线程下的多个任务能在一个任务遇到io阻塞时就切换到另外一个任务去计算,这样就保证了该线程能够最大限度地处于就绪态,即随时都可以被cpu执行的状态,相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来,从而可以迷惑操作系统,让其看到:该线程好像是一直在计算,io比较少,从而更多的将cpu的执行权限分配给我们的线程。
协程的本质就是在单线程下,由用户自己控制一个任务遇到io阻塞了就切换另外一个任务去执行,以此来提升效率。
#1. 可以控制多个任务之间的切换,切换之前将任务的状态保存下来,以便重新运行时,可以基于暂停的位置继续执行。#2. 作为1的补充:可以检测io操作,在遇到io操作的情况下才发生切换协程介绍
协程:是单线程下的并发,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程,即协程是由用户程序自己控制调度的。、
需要强调的是:
#1. python的线程属于内核级别的,即由操作系统控制调度(如单线程遇到io或执行时间过长就会被迫交出cpu执行权限,切换其他线程运行) #2. 单线程内开启协程,一旦遇到io,就会从应用程序级别(而非操作系统)控制切换,以此来提升效率(!!!非io操作的切换与效率无关)对比操作系统控制线程的切换,用户在单线程内控制协程的切换
优点如下:
#1. 协程的切换开销更小,属于程序级别的切换,操作系统完全感知不到,因而更加轻量级 #2. 单线程内就可以实现并发的效果,最大限度地利用cpu缺点如下:
#1. 协程的本质是单线程下,无法利用多核,可以是一个程序开启多个进程,每个进程内开启多个线程,每个线程内开启协程 #2. 协程指的是单个线程,因而一旦协程出现阻塞,将会阻塞整个线程总结协程特点:
- 必须在只有一个单线程里实现并发
- 修改共享数据不需加锁
- 用户程序里自己保存多个控制流的上下文栈
- 附加:一个协程遇到IO操作自动切换到其它协程(如何实现检测IO,yield、greenlet都无法实现,就用到了gevent模块(select机制))
Greenlet
如果我们在单个线程内有20个任务,要想实现在多个任务之间切换,使用yield生成器的方式过于麻烦(需要先得到初始化一次的生成器,然后再调用send。。。非常麻烦),而使用greenlet模块可以非常简单地实现这20个任务直接的切换
#安装 pip3 install greenletfrom greenlet import greenletdef eat(name):print('%s eat 1' %name)g2.switch('egon')print('%s eat 2' %name)g2.switch() def play(name):print('%s play 1' %name)g1.switch()print('%s play 2' %name)g1=greenlet(eat) g2=greenlet(play)g1.switch('egon')#可以在第一次switch时传入参数,以后都不需要单纯的切换(在没有io的情况下或者没有重复开辟内存空间的操作),反而会降低程序的执行速度
#顺序执行 import time def f1():res=1for i in range(100000000):res+=idef f2():res=1for i in range(100000000):res*=istart=time.time() f1() f2() stop=time.time() print('run time is %s' %(stop-start)) #10.985628366470337#切换 from greenlet import greenlet import time def f1():res=1for i in range(100000000):res+=ig2.switch()def f2():res=1for i in range(100000000):res*=ig1.switch()start=time.time() g1=greenlet(f1) g2=greenlet(f2) g1.switch() stop=time.time() print('run time is %s' %(stop-start)) # 52.763017892837524View Code
greenlet只是提供了一种比generator更加便捷的切换方式,当切到一个任务执行时如果遇到io,那就原地阻塞,仍然是没有解决遇到IO自动切换来提升效率的问题。
单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作,我们完全可以在执行任务1时遇到阻塞,就利用阻塞的时间去执行任务2。。。。如此,才能提高效率,这就用到了Gevent模块。
Gevent
#安装 pip3 install geventGevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。
#用法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的返回值遇到IO阻塞时会自动切换任务
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('主')上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,
而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all()必须放到被打补丁者的前面,如time,socket模块之前
或者我们干脆记忆成:要用gevent,需要将from gevent import monkey;monkey.patch_all()放到文件的开头
from gevent import monkey;monkey.patch_all()import gevent import time def eat():print('eat food 1')time.sleep(2)print('eat food 2')def play():print('play 1')time.sleep(1)print('play 2')g1=gevent.spawn(eat) g2=gevent.spawn(play_phone) gevent.joinall([g1,g2]) print('主')View Code
我们可以用threading.current_thread().getName()来查看每个g1和g2,查看的结果为DummyThread-n,即假线程
gevent应用示例:
from gevent import monkey;monkey.patch_all() import gevent import requests import timedef get_page(url):print('GET: %s' %url)response=requests.get(url)if response.status_code == 200:print('%d bytes received from %s' %(len(response.text),url))start_time=time.time() gevent.joinall([gevent.spawn(get_page,'https://www.python.org/'),gevent.spawn(get_page,'https://www.yahoo.com/'),gevent.spawn(get_page,'https://github.com/'), ]) stop_time=time.time() print('run time is %s' %(stop_time-start_time))协程应用:简单爬虫
转载于:https://www.cnblogs.com/tianleblog/p/7474948.html
python学习点滴记录-Day10-线程相关推荐
- python学习点滴记录-Day09
网络编程之基于udp协议的套接字 基于UDP协议的套接字 udp是无链接的,面向消息的(有报头有数据),先启动哪一端都不会报错,也不会发生粘包现象. udp服务端 1 ss = socket() #创 ...
- python学习点滴记录-Day07
面向对象 摘自林老师博客http://www.cnblogs.com/linhaifeng/articles/6182264.html#_label7 理论 什么是面向对象的程序设计及为什么要有它? ...
- python学习自记录(2)开发工具的pycharm安装使用,编写的第一个应声虫程序
python学习自记录(2)开发工具的pycharm安装使用 1.下载安装 链接:https://pan.baidu.com/s/18ARXYybcoMrRi96gfIh6Zg 密码:qydc 下方注 ...
- ql的python学习之路-day10
前言:本节主要讲解迭代器和生成器 迭代器&生成器 一.生成器(generator) 循环占用大部分的容量内存,如果只需要循环前面的几个结果那怎么样做呢,在python中有一种一边循环一边计算的 ...
- python学习总结记录
python阶段学习总结 文章目录 python阶段学习总结 1.序列类型(列表 元组 字典 集合) 2.常见函数 3.运算符 4.字符串和正则表达式 5.面向对象 6.编码与文件操作 7.变量作用域 ...
- 小甲鱼Python学习知识点记录(003讲)
一.插曲之变量 1.变量名就像我们现实社会的名字,把一个值赋值给一个名字时,它会存储在内存中,称之为变量(variable),在大多数语言中,都把这种行为称为"给变量赋值"或&qu ...
- python异常处理_Python学习点滴04 - 学会异常处理(2)
前言 我们在开发Python程序时经常会遇到一些错误(语法错误和异常),尤其是程序代码发生异常(Exceptions)时,如果不能及时捕获异常和有效处理异常,则程序运行会被终止,有可能会造成相应的后果 ...
- Python学习之面向对象编程
Python学习目录 在Mac下使用Python3 Python学习之数据类型 Python学习之函数 Python学习之高级特性 Python学习之函数式编程 Python学习之模块 Python学 ...
- 金融民工python学习笔记
金融民工python学习笔记 #仅用于个人python学习的记录,便于查看和复习 利用pandas_datareader获取股票信息 参考链接:https://www.jianshu.com/p/63 ...
最新文章
- 如何将简单CMS后台管理系统示例转换为Java、Php等不同后台语言的版本
- Android 解析包出错问题
- ASP.NET 4新增功能(三) 对Web标准的支持和辅助功能的增强
- 核密度估计Kernel Density Estimation(KDE)-代码详细解释
- Shovels and Swords CodeForces - 1366A(二分)
- Python爬虫入门学习--中国大学排名
- 首届恩智浦智能车比赛回顾
- 世界500强面试题(经典)
- 网络分析仪测试线损_网络分析仪测试天线隔离度
- [收藏] Flash闪存颗粒和工艺知识深度解析
- 鸿蒙系统吹了多少年了还没出,实话实说,在鸿蒙系统上,余承东吹了几次牛都没实现...
- WP个人主题源码Cosy3.1.3
- matlab 图片叠加
- h5 php 拍照上传图片,H5拍照、选择图片上传组件核心
- APP系列,学院专题讲座图像记录软件推荐
- 从车辆工程到大数据开发,我经历了什么?
- 由siri谈苹果公司的发展
- 计算机突然断电恢复供电后,电脑突然断电的坏处有哪些?
- Python中运用的基础库
- 看医疗行业如何建立信息化战略决策