一:进程:进程是操作系统结构的基础;是一个正在执行的程序;计算机中正在运行的程序实例;可以分配给处理器并由处理器执行的一个实体;由单一顺序的执行显示,一个当前状态和一组相关的系统资源所描述的活动单元
1.多进程
由于GIL的存在,python中的多线程其实并不是真正的多线程,如果想要充分地使用多核CPU的资源,在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing,只需要定义一个函数,Python会完成其他所有事情。借助这个包,可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同步,提供了Process、Queue、Pipe、Lock等组件。 multiprocessing包是Python中的多进程管理包。与threading.Thread类似,它可以利用multiprocessing.Process对象来创建一个进程。该进程可以运行在Python程序内部编写的函数。该Process对象与Thread对象的用法相同,也有start(), run(), join()的方法。此外multiprocessing包中也有Lock/Event/Semaphore/Condition类 (这些对象可以像多线程那样,通过参数传递给各个进程),用以同步进程,其用法与threading包中的同名类一致。所以,multiprocessing的很大一部份与threading使用同一套API,只不过换到了多进程的情境。 但在使用这些共享API的时候,我们要注意以下几点: 在UNIX平台上,当某个进程终结之后,该进程需要被其父进程调用wait,否则进程成为僵尸进程(Zombie)。所以,有必要对每个Process对象调用join()方法 (实际上等同于wait)。对于多线程来说,由于只有一个进程,所以不存在此必要性。 multiprocessing提供了threading包中没有的IPC(比如Pipe和Queue),效率上更高。应优先考虑Pipe和Queue,避免使用Lock/Event/Semaphore/Condition等同步方式 (因为它们占据的不是用户进程的资源)。 多进程应该避免共享资源。在多线程中,我们可以比较容易地共享资源,比如使用全局变量或者传递参数。在多进程情况下,由于每个进程有自己独立的内存空间,以上方法并不合适。此时我们可以通过共享内存和Manager的方法来共享资源。但这样做提高了程序的复杂度,并因为同步的需要而降低了程序的效率。 Process.PID中保存有PID,如果进程还没有start(),则PID为None。 window系统下,需要注意的是要想启动一个子进程,必须加上那句if __name__ == "main",进程相关的要写在这句下面。
来直接看一下代码
from multiprocessing import Process import time def f(name): time.sleep(1) print("hello",name,time.ctime()) if __name__ == "__main__": p_list = [] for i in range(3): p = Process(target = f,args = ("alex",)) p_list.append(p) p.start() for i in p_list: p.join() #注意这个地方得到join,等到上面的所有执行完以后再执行最后的end print("end")结果为:
hello alex Wed Oct 12 16:50:18 2016
hello alex Wed Oct 12 16:50:18 2016
hello alex Wed Oct 12 16:50:18 2016
end
2.类式调用
from multiprocessing import Process import time class MyProcess(Process): def __init__(self,): super(MyProcess,self).__init__() #self.name = name def run(self): time.sleep(1) print("hello",self.name,time.ctime()) #此时的self.name 是进程对象下的一个属性,是有名字的, if __name__ == "__main__": p_list =[] for i in range(3): p = MyProcess() p.start() p_list.append(p) for p in p_list: p.join() print("end")结果为:
hello MyProcess-1 Wed Oct 12 16:59:27 2016
hello MyProcess-2 Wed Oct 12 16:59:27 2016
hello MyProcess-3 Wed Oct 12 16:59:27 2016
end
3.进程关系(父进程与子进程之间的关系)
from multiprocessing import Process import os import time def info(title): print(title) print("module name:",__name__) print("parent process:",os.getppid()) print("process id:",os.getpid()) def f(name): info("\033[3;1mfunction f\033[0m") print("hello",name) if __name__ == "__main__": info("\033[32;1mmain process line\033[0m") time.sleep(2) p = Process(target = info,args=("bob",)) p.start() p.join()结果为:
main process line
module name: __main__
parent process: 12888
process id: 13432
bob
module name: __mp_main__
parent process: 13432
process id: 13036
二:Process类
构造方法: Process([group [, target [, name [, args [, kwargs]]]]]) group: 线程组,目前还没有实现,库引用中提示必须是None; target: 要执行的方法; name: 进程名; args/kwargs: 要传入方法的参数。 实例方法: is_alive():返回进程是否在运行。 join([timeout]):阻塞当前上下文环境的进程程,直到调用此方法的进程终止或到达指定的timeout(可选参数)。 start():进程准备就绪,等待CPU调度 run():strat()调用run方法,如果实例进程时未制定传入target,这star执行t默认run()方法。 terminate():不管任务是否完成,立即停止工作进程 属性: authkey daemon:和线程的setDeamon功能一样 exitcode(进程在运行时为None、如果为–N,表示被信号N结束) name:进程名字。 pid:进程号。
三:进程间通讯:这里都是通过代码来看的
3.1首先来看一个队列,进程队列queue
from multiprocessing import Process, Queue def f(q,n): q.put([42, n, ‘hello‘]) if __name__ == ‘__main__‘: q = Queue() p_list=[] for i in range(3): p = Process(target=f, args=(q,i)) p_list.append(p) p.start() print(q.get()) print(q.get()) print(q.get()) for i in p_list: i.join()
3.2 pipe
# import os # # from multiprocessing import Process, Pipe # # def f(conn): # conn.send(‘约吗‘) # print(conn.recv(),‘in the %s‘%os.getpid()) # conn.close() # # if __name__ == ‘__main__‘: # parent_conn, child_conn = Pipe() # p = Process(target=f, args=(child_conn,)) # p2 = Process(target=f, args=(child_conn,)) # p.start() # p2.start() # print(parent_conn.recv()) # prints "[42, None, ‘hello‘]" # print(parent_conn.recv()) # prints "[42, None, ‘hello‘]" # parent_conn.send(‘hello‘) # parent_conn.send(‘hello2‘) # # p.join()
4. manager 来实现一个数据共享
from multiprocessing import Process, Manager def f(d,l,n): d[n] = ‘1‘ d[‘2‘] = 2 d[0.25] = None l.append(n) #print(l) print(‘sub‘,id(d)) if __name__ == ‘__main__‘: with Manager() as manager:# with open() as f== f=open() manager=Manager() d = manager.dict() l = manager.list(range(5)) p_list = [] print(‘main‘,id(d)) for i in range(10): p = Process(target=f, args=(d,l,i)) p.start() p_list.append(p) for res in p_list: res.join() print(d) print(l)
四:进程池
进程池内部维护一个进程序列,当使用时,则去进程池中获取一个进程,如果进程池序列中没有可供使用的进进程,那么程序就会等待,直到进程池中有可用进程为止。
进程池中有两个方法:
- apply
- apply_async
from multiprocessing import Process, Pool import time import os def Foo(i): time.sleep(2) print(‘sub %s‘%os.getpid()) return i + 100 def Bar(arg): print(‘Bar:‘,os.getpid()) print(‘-->exec done:‘, arg) if __name__==‘__main__‘: pool = Pool() print(‘main:‘,os.getpid()) for i in range(10): pool.apply_async(func=Foo, args=(i,),callback=Bar) #pool.apply(func=Foo, args=(i,)) print(‘end‘) pool.close() pool.join()
第二部分: 协程
协程 协程,又称微线程,纤程。英文名Coroutine。一句话说明什么是线程:协程是一种用户态的轻量级线程。 协程拥有自己的寄存器上下文和栈。协程调度切换时,将寄存器上下文和栈保存到其他地方,在切回来的时候,恢复先前保存的寄存器上下文和栈。因此: 协程能保留上一次调用时的状态(即所有局部状态的一个特定组合),每次过程重入时,就相当于进入上一次调用的状态,换种说法:进入上一次离开时所处逻辑流的位置。 协程的好处: 无需线程上下文切换的开销 无需原子操作锁定及同步的开销 方便切换控制流,简化编程模型 高并发+高扩展性+低成本:一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。 缺点: 无法利用多核资源:协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要,除非是cpu密集型应用。 进行阻塞(Blocking)操作(如IO时)会阻塞掉整个程序
我们来看例子慢慢认识协程
1. yield支持下的协程 yield有一个并发的效果,在这里其实实现的就是一个协程
首先我们先来简单的回顾一下yield,比如说
def f(): print("ok") f() # 这种情况下回正常执行函数打印出结果为OK,看下面 def f(): print("OK") yield f() # 这个时候是什么都没有,为什么,这里的yield是一个生成器 print(f()) #<generator object f at 0x00000000006AC048>,那我们怎样去打印出上面的结果呢,看下面加的一些
gen = f()next(gen)
next(gen) #这样我们就可以取到值 注意: gen.__next__()和next(gen)是等价的
如果我们在yield下面加上这样
print(‘ok1‘)yield 5print("OK2") 这样的话OK2也是不会打印的,因为此时yield已经折回了,当然要想打印出OK2,我们再来一个next就行,还需要一个yieldyield 7 最后面next(gen)这样就可以实现 yield 后面是可以跟参数的,那么我们如何取到yield后面的参数值呢,因为返回的其实就是next(gen),所以呢,看下面这样就可以取到返回值ret = next(gen)print(ret) 此时取到的就是返回值
我们除了next进入生成器对象里面我们还可以通过send进入,看下面例子count = yield 5print(count)x = gen.send(10)print(x)但是如果我们开始直接就send一个值是不行的,必须传入一个空值才行,就是gen.send(None) 我这里写的有一点乱,可以看下面的代码在一步步看我的就而已理解了
def f(): print(‘ok1‘) count=yield 5 print(count) print(‘ok2‘) yield 67 #print(f()) #<generator object f at 0x00000000006AC048> gen=f() # ret=next(gen) # print(ret) next(gen)#gen.send(None)# x=gen.send(10) print(x)#67
再来看一个例子
import time import queue def consumer(name): print("--->starting ...") while True: new_baozi = yield print("[%s] is eating baozi %s" % (name, new_baozi)) # time.sleep(1) def producer(): next(con) next(con2) n = 0 while n < 5: n += 1 print("\033[32;1m[producer]\033[0m is making baozi %s" % n) con.send(n) con2.send(n) if __name__ == ‘__main__‘: con = consumer("c1") # 创建一个生成器对象con con2 = consumer("c2") # 创建一个生成器对象con2 p = producer() # 执行producer函数,p就是函数返回值
2.Greenlet 下的协程
from greenlet import greenlet def test1(): print(12) gr2.switch() print(34) gr2.switch() def test2(): print (56) gr1.switch() print (78) gr1 = greenlet(test1) gr2 = greenlet(test2) #这里也是生成了一个对象 print(gr1) print(gr2)结果为:
<greenlet.greenlet object at 0x000000CD25A1FCC0>
<greenlet.greenlet object at 0x000000CD25A1FDF0>
12
56
34
78
3.gevent 下 支持 的 协程
Gevent 是一个第三方库,可以轻松通过gevent实现并发同步或异步编程,在gevent中用到的主要模式是Greenlet, 它是以C扩展模块形式接入Python的轻量级协程。 Greenlet全部运行在主程序操作系统进程的内部,但它们被协作式地调度。
首先我们要装一个gevent,在file下找到setting下的这个选项就可以在里面添加各种你所需要的配置
来看一个例子
# import gevent # import time # # def foo(): # print(‘Running in foo‘,time.ctime()) # gevent.sleep(1) #这里有同学可能会问为什么不用time,如果用time的话这就是一个串行的过程,就不会切换了, # print(‘Explicit context switch to foo again‘,time.ctime()) # # # def bar(): # print(‘Explicit context to bar‘,time.ctime()) # gevent.sleep(2) # print(‘Implicit context switch back to bar‘,time.ctime()) # # gevent.joinall([ # gevent.spawn(foo), # gevent.spawn(bar), # ]) 结果为:
runing in foo Fri Oct 14 17:18:38 2016
explicit context to bar Fri Oct 14 17:18:38 2016
explicit context switch to foo again Fri Oct 14 17:18:39 2016
implicit context switch back to bar Fri Oct 14 17:18:40 2016
再来看一个爬虫的例子,比如说校花网
#爬虫 # from gevent import monkey # monkey.patch_all() #最大程度的利用IO阻塞 # import gevent # from urllib.request import urlopen # import time # def f(url): # print("GET: %s" % url) # resp = urlopen(url) # data = resp.read() # with open("xiaohuawang.html","wb")as f: # f.write(data) # print("%d bytes received from %s." % (len(data),url)) # #l = ["http://www.python.org/","http://www.yahoo.com/","http://github.com/"] # start = time.time() # for url in l: # f(url) #是等价于下面的, # gevent.joinall([ # gevent.spawn(f,"http://www.xiaohuar.com/"), # # gevent.spawn(f,"http://www.yahoo.com/"), # # gevent.spawn(f,"http://github.com/"), # ]) # print(time.time() - start) #