import multiprocessing#多进程包
import time
def visit(name):time.sleep(1)print('hello', name,time.ctime())if __name__ == '__main__':p_list=[]for i in range(3):p = multiprocessing.Process(target=visit, args=('alvin',))#创建子进程对象p_list.append(p)p.start()#开启进程for i in p_list:p.join()#与线程意义先疼痛print('end')

class MyProcess(Process):def run(self):time.sleep(1)print ('hello', self.name,time.ctime())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')

class progress(multiprocessing.Process):def run(self):time.sleep(2)print("process name",self.name)print("parent process id",os.getppid(),time.time())print("process id",os.getpid(),time.time())
if __name__=="__main__":print("main process line")progress.run(progress)print("----------")t1=progress()t2=progress()t1.start()t2.start()#主进程的parent process id 33440 1550129555.0609472
#主进程的process id 21996 1550129555.0609472
#子进程process name progress-1parent process id 21996 1550129557.234302process id 29496 1550129557.234302

import multiprocessing,time
def foo(parad):time.sleep(1)print("子进程队列id",id(parad))parad.put("name")parad.put({"name":"alex"})
if __name__=="__main__":p_list=[]parad=multiprocessing.Queue()#创建一个进程队列print("主进程队列",id(parad))for i in range(3):progress=multiprocessing.Process(target=foo,args=(parad,))progress.start()print(parad.get())print(parad.get())

def foo(conn):time.sleep(1)conn.send("hellow father")print("子进程收：",conn.recv())conn.close()
if __name__=="__main__":parent_conn, child_conn = multiprocessing.Pipe()#创建一个管道对象progress=multiprocessing.Process(target=foo,args=(child_conn,))#将管道一方传送到子进程progress.start()print("主线程收：",parent_conn.recv())#接收数据parent_conn.send("hellow son")#发送数据progress.join()print("ending...")

A manager object returned by Manager() controls a server process which holds Python objects and allows other processes to manipulate them using proxies.

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array. For example：

def foo(dict,list,i,string):dict["name"]="tom"list[0]=5list.append(i)string="i am tom"print("son process",id(dict),id(list))
if __name__=="__main__":with multiprocessing.Manager() as manager:dict=manager.dict({"name":"alex"})list=manager.list([1,2,3,4])string=manager.Value("i am alex")p_list=[]for i in range(2):progress=multiprocessing.Process(target=foo,args=(dict,list,i,string))p_list.append(progress)progress.start()for i in p_list:i.join()print(dict)print(list)print(string)print("father process", id(dict), id(list))

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止

进程池中的方法：

• apply 从进程池里取一个进程并同步执行
• apply_async 从进程池里取出一个进程并异步执行
• terminate 立刻关闭进程池
• join 主进程等待所有子进程执行完毕，必须在close或terminete之后
• close 等待所有进程结束才关闭线程池

·

 1 import multiprocessing,time,os
 2 def foo(i):
 3     time.sleep(1)
 4     print(i,time.time())
 5     print("son",os.getpid())#17728
 6 def success(arg):
 7     print("success",os.getpid())#18340
 8 def fail(arg):
 9     print("falid")
10 if __name__ == '__main__':
11     print("main:",os.getpid())#18340
12     pool=multiprocessing.Pool()
13     lock=multiprocessing.Lock()
14     for i in range(20):
15         pool.apply_async(func=foo,args=(i,),callback=success,error_callback=fail)
16         #pool.apply(func=foo,args=(i,))
17     pool.close()
18     pool.join()
19     print("ending....")

进程池

所谓协程又称为微线程，我们在进程在创建时， 需要耗费时间和cpu资源；在创建多线程时，也需要消耗时间和资源。利用多协程的运行过程中，始终只要一个线程， 不存在创建线程和销毁线程需要的时间； 也没有线程切换的开销， 任务需要开启线程数越多， 协程的优势越明显；更不需要多线程的锁机制(GIL)。

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

协程的优点：

　　（1）无需线程上下文切换的开销，协程避免了无意义的调度，由此可以提高性能（但也因此，程序员必须自己承担调度的责任，同时，协程也失去了标准线程使用多CPU的能力）

　　（2）无需原子操作锁定及同步的开销

　　（3）方便切换控制流，简化编程模型

　　（4）高并发+高扩展性+低成本：一个CPU支持上万的协程都不是问题。所以很适合用于高并发处理。

协程的缺点：

　　（1）无法利用多核资源：协程的本质是个单线程,它不能同时将 单个CPU 的多个核用上,协程需要和进程配合才能运行在多CPU上.当然我们日常所编写的绝大部分应用都没有这个必要，除非是cpu密集型应用。

　　（2）进行阻塞（Blocking）操作（如IO时）会阻塞掉整个程序

def consumer(name):print("我要吃包子")while True:baozi=yieldprint("%s eating %s 包子"%(name,baozi))
def producer(name):c1.__next__()c2.__next__()n=0while True:print("\033[32;1m[producer]\033[0m is making baozi %s and %s" % (n, n + 1))c1.send(n)c2.send(n+1)n+=2if __name__ == '__main__':c1=consumer("alex")c2=consumer("tom")p1=producer("cookie")

import greenlet
def test1():print(12)g2.switch()print(34)g2.switch()print(96)
def test2():print(56)g1.switch()print(78)
g1=greenlet.greenlet(test1)#创建一个协程对象
g2=greenlet.greenlet(test2)
g1.switch()#启动协程/切换协程

gevnet是协程之间的自动切换

import gevent
def func1():print(12)gevent.sleep(2)print(56)def func2():print(34)gevent.sleep(1)print(78)
t1=gevent.spawn(func1)#创建一个线程对象
t2=gevent.spawn(func2)
print(t1)
gevent.joinall([t1,t2])#添加线程对象，并运行线程