python---进程与线程（四）---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()：不管任务是否完成，立即停止工作进程
属性：
　　daemon：和线程的setDeamon功能一样
　　name：进程名字。

　　pid：进程号。

import multiprocessingclass MyProcess(multiprocessing.Process):    def __init__(self):        super().__init__()    def run(self):        print('{} say ok'.format(self.name))if __name__ == '__main__':    p=MyProcess()    p.start()

=================================================================

 进程队列Queue

# import multiprocessing## def foo(q):#     q.put('ds')### q = multiprocessing.Queue()# if __name__ == '__main__':##     p=multiprocessing.Process(target=foo,args=(q,))#     p.start()#     print(q.get())

=================================================================

Pipe()

Pipe的本质是进程之间的数据传递，而不是数据共享，这和socket有点像。pipe()返回两个连接对象分别表示管道的两端，每端都有send()和recv()方法。如果两个进程试图在同一时间的同一端进行读取和写入那么，这可能会损坏管道中的数据。

# from multiprocessing import Pipe,Process## def foo(conn):#     conn.send('dw')#     print(conn.recv())### if __name__ == '__main__':#     sock, conn = Pipe()#     q=Process(target=foo,args=(conn,))#     q.start()##     print(sock.recv())#     sock.send('dd')

=================================================================

 Manager

Queue和pipe只是实现了数据交互，并没实现数据共享，即一个进程去更改另一个进程的数据。
       通过Manager可实现进程间数据的共享。Manager()返回的manager对象会通过一个服务进程，来使其他进程通过代理的方式操作python对象。manager对象支持 list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value ,Array.

# from multiprocessing import Manager,Process## def foo(d,x,y):#     d[x]=y# if __name__ == '__main__':#     manager=Manager()#     Mdict=manager.dict({'kill':9572})#     l=[]#     for i in range(5):#         p=Process(target=foo,args=(Mdict,'dog{}'.format(i),i))#         p.start()#         l.append(p)#     for j in l :#         j.join()##     print(Mdict)

=================================================================

进程池
由于进程启动的开销比较大，使用多进程的时候会导致大量内存空间被消耗。为了防止这种情况发生可以使用进程池，（由于启动线程的开销比较小，所以不需要线程池这种概念，多线程只会频繁得切换cpu导致系统变慢，并不会占用过多的内存空间）
进程池中常用方法：
apply() 同步执行（串行）
apply_async() 异步执行（并行）
terminate() 立刻关闭进程池

close() 等待所有进程结束后，才关闭进程池。

join() 主进程等待所有子进程执行完毕。必须在close或terminate()之后。

# from multiprocessing import Pool# import time## def foo(n):#     print(n)#     time.sleep(1)# if __name__ == '__main__':#     pool_obj=Pool(5)#进程池内有5个进程##     for i in range(100):#开100任务#         p=pool_obj.apply_async(func=foo,args=(i,))##     print(p,type(p))#     print(pool_obj,type(pool_obj))#     pool_obj.close()#     pool_obj.join()

=================================================================

协程

协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。
       协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此：协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。

yield实现协程

# import time## def consumer():#     r = ''#     while True:#         n = yield r#         print('消费%s'%n)#         time.sleep(1)#         r='200 ok'## def produce(c):#     next(c)#     n = 0#     while n<5:#         n+=1#         print('生产%s'%n)#         cr = c.send(n)##         print('消费反馈%s'%cr)#     c.close()## if __name__ == '__main__':#     c=consumer()#     produce(c)

-------------------------------------------------------------------------------------------------------------------

greenlet模块

greenlet机制的主要思想是：生成器函数或者协程函数中的yield语句挂起函数的执行，直到稍后使用next()或send()操作进行恢复为止。可以使用一个调度器循环在一组生成器函数之间协作多个任务。greentlet是python中实现我们所谓的"Coroutine(协程)"的一个基础库.

import greenletdef foo():    print(1)    b.switch()    print(3)    b.switch()def bar():    print(2)    f.switch()    print(4)f=greenlet.greenlet(foo)b=greenlet.greenlet(bar)f.switch()

-------------------------------------------------------------------------------------------------------------------

       Python通过yield提供了对协程的基本支持，但是不完全。而第三方的gevent为Python提供了比较完善的协程支持。
gevent是第三方库，通过greenlet实现协程，其基本思想是：
        当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO。
       由于切换是在IO操作时自动完成，所以gevent需要修改Python自带的一些标准库，这一过程在启动时通过monkey patch完成。

# import re,requests,time,gevent# def foo(url):##     response=requests.get(url)#     response_str=response.text#     return response_str## def bar(url):#     res=foo(url)#     obj=re.compile('<img src="(.*?)" width="251" height="360" title=".*?" alt=".*?">',re.S)#     lis = obj.findall(res)#     print(lis)# if __name__ == '__main__':#     s=time.time()#     gevent.joinall([gevent.spawn(bar,'http://www.youwu.cc/tag/boluoshe/list_1.html'),    #                gevent.spawn(bar, 'http://www.youwu.cc/tag/boluoshe/list_2.html'),    #                gevent.spawn(bar, 'http://www.youwu.cc/tag/boluoshe/list_3.html'),    #                gevent.spawn(bar, 'http://www.youwu.cc/tag/boluoshe/list_4.html'),    #                gevent.spawn(bar, 'http://www.youwu.cc/tag/boluoshe/list_5.html')])    # print(time.time()-s)