多进程

windows和unix/linux系统的区别：

unix/linux系统提供了一个fork()系统调用，普通函数调用一次返回一次，而fork()调用一次返回两次。
而windows系统上没有fork()调用


第一种方法创建子进程：linux/unix独有
    linux/unix系统使用fork()函数创建子进程，模式如下：
    #!/usr/bin/env python
    import os
    print "process %s start....." % (os.getpid())

    pid=os.fork()                        pid有两种值，一种是0（代表子进程），另外一种是子进程ID（代表父进程）
    if pid == 0:                        当pid=0的时候，os.getpid()得到子进程，os.getppid()得到父进程
        print "child process %s and parent process %s" % (os.getpid(),os.getppid())
    else:                                否则pid等于子进程ID，os.getpid()得到父进程    
        print "I am parent %s create %s " % (os.getpid(),pid)


第二种方法：通过一个multiprocess模块中的类Process来创建子进程。通用linux,windows ,unix

    from multiprocessing import Process
    import os

    def run_proc(name):
        print "run child process %s %s...." % (name,os.getpid())

    if __name__ == "__main__":
        print "parent process %s..." % (os.getpid())
        p=Process(target=run_proc,args=("test",))           创建一个Process类的实例，并且传入一个函数和参数
        print "child process will start"
        p.start()                                    通过start来启动
        p.join()                                    join方法可以等待子进程结束后再往下继续执行    ，用于进程间同步
        print "child process end"
    

第三中方法：用进程池批量创建子进程

   方法一：我们通过Pool类创建出25各进程，然后再创建100各任务，然后每个进程执行4个任务，并把执行后的结果放在一个列表中，最后我们通过.get遍历这个列表把结果取出来
   
    #!/usr/bin/env python
    import multiprocessing
    import sys,os,time

    print "Parent process：%s" % (os.getpid())
    result=[]
    def run(h):
        print "threading test:",h,os.getpid()            
        time.sleep(2)                                        
    p=multiprocessing.Pool(processes=25)                一次创建25各进程。
                                                                                            
    for i in range(100):                                
        result.append(p.apply_async(run,('%s'%i,)))        执行run函数100次，并把执行的结果放在一个列表中，相当于每个进行执行函数4次

    p.close()                                                                    
    p.join()

    for res in  result:
        res.get(timeout=5)                                通过.get获取列表中的元素
        
    
    方法二：不需要通过列表，也可得出执行后的结果
    
    #!/usr/bin/env python
    #! -*- encoding:utf-8 -*-
    from multiprocessing import Pool
    import os,time,random

    def long_time_task(name):
        print "run tas %s: %s" % (name,os.getpid())
        start = time.time()
        time.sleep(random.random() * 3)
        end = time.time()
        print "task %s runs %0.2f seconds" % (name,(end - start))

    if __name__ == "__main__":
        print "parent process %s " % os.getpid()
        p=Pool(5)
        for i in xrange(5):
            p.apply_async(long_time_task,args=(i,))            
        print "waiting for all subprocess done "        
        p.close()                    join方法可以等待子进程结束后再往下继续执行，在join之前要先close，close之后不会添加新的process
        p.join()                            

    

    注意：如果我们有5各cpu，然后我们创建5个进程，执行5个任务的话，那么平均每个进程会占用一个cpu，并且执行一个任务，这时5各任务会同时执行，看不到等待效果。

    
    
    
------进程间的通信机制：通过Queue，Pipes来交换数据---------
'''

from multiprocessing import Process,Queue
import os,time,random

def write(q):                                       #定义一个写函数
    print("Process to write: %s" % os.getpid())
    for value in ["a","b","c","d"]:
        print "put %s to queue.." % value
        q.put(value)
        time.sleep(random.random())

def read(q):                                        #定义一个读函数
    print "process %s to read" % os.getpid()
    while True:
        value = q.get(True)
        print "get %s from queue" % value

if __name__ == "__main__":
    q=Queue()                                   #创建Queue对象
    pw=Process(target=write,args=(q,))          #创建一个写进程
    pr=Process(target=read,args=(q,))           #创建一个读进程

    pw.start()                          #开启读进程
    pr.start()                          #开启写进程

    pw.join()                       #等待写进程结束

    pr.terminate()                  #由于读进程用的是死循环，无法等待其结束，只有强制结束