进程初学

#!/usr/bin/env python
#-*-coding:utf-8-*-
__author__ = 'BinZhou'

import multiprocessing
import time
import os
'''
1.1、什么是守护进程？
  1、守护进程会在主进程代码运行结束的情况下，立即挂掉。
  2、守护进程本身就是一个子进程。
  3、主进程在其代码结束后就已经算运行完毕了（守护进程在此时就被回收）,
  然后主进程会一直等非守护的子进程都运行完毕后回收子进程的资源(否则会产生僵尸进程)，才会结束，
1.2、为什么要用守护进程？
 1、守护进程本身就是一个子进程，所以在主进程需要将任务并发执行的时候需要开启子进程。
  2、当该子进程执行的任务生命周期伴随着主进程的生命周期时，就需要将该子进程做成守护进程。

2.1、什么是守护线程？
  1、守护线程会在"该进程内所有非守护线程全部都运行完毕后,守护线程才会挂掉"。并不是主线程运行完毕后守护线程挂掉。
  这一点是和守护进程的区别之处！
  2、守护线程守护的是：当前进程内所有的子线程！
  3、主线程在其他非守护线程运行完毕后才算运行完毕（守护线程在此时就被回收）。因为主线程的结束意味着进程的结束，
  进程整体的资源都将被回收，而进程必须保证非守护线程都运行完毕后才能结束。
2.2、主线程与进程的关系
  1、主线程的生命周期就是一个进程的生命周期
  2、主进程等待子进程是因为主进程要负责回收子进程的系统资源，主线程等待子线程是因为主线程要等待子线程运行完毕
  (子线程运行完毕后,这个进程才算运行完毕)后,主线程才结束。
进程池：
  我们为进程注入func，有两种方式：apply_async表示异步，就是子进程接收到请求之后就各自去执行了，而apply表示同步，
  子进程们将一个一个的执行，
  后一个子进程的执行永远以前一个子进程的结束为信号，开始执行。还是吃饭的例子。。。异步就是当我通知子进程要去吃饭
  的时候，他们就同时去吃饭了，同步就是他们必须一个一个的去，前一个没回来，后一个就不能去。

进程之间内存共享：
我们之前说过，正常情况下，每个进程都拥有自己的内存空间，因此进程间的内存是无法共享的。但是python却提供了我们方法，
让我们程序的子进程之间实现简单的数据共享。
一个是Array数组，一个是multiprocessing模块中的Manager类。需要注意的是，Array数组的大小必须固定，Manager需要在linux系统下运行。
参考：http://www.cnblogs.com/Eva-J/articles/5110844.html
'''

def func1(name):
    start_time = time.time()
    print('Im in func1%s-%s-%s' %(name,func1.__name__,os.getpid()))
    time.sleep(3)
    end_time = time.time()
    print(end_time - start_time)

def func2(name):
    start_time = time.time()
    print('Im in func2%s-%s-%s' %(name,func2.__name__,os.getpid()))
    time.sleep(3)
    end_time = time.time()
    print(end_time - start_time)


if __name__ == '__main__': #需要注意的是要想启动一个子进程，必须加上那句if __name__ == "main"，否则就会报错
                            #我们必须确定当前已经引入了主模块，来避免一些非预期的副作用
    # print('Parent process %s.' % os.getpid())
    # befor_time = time.time()
    # func1('hello')
    # func2('world')
    # after_time = time.time()
    # print(after_time - befor_time)# used time 6.0190112590789795

    print('Parent process %s.' % os.getpid())#打印当前进程id
    p1 = multiprocessing.Process(target=func1,args=('hello',))#创建新进程实例 args参数必须以元组方式;
    p2 = multiprocessing.Process(target=func2,args=('world',))#创建新进程实例 args参数必须以元组方式;
    # 如果在创建Process对象的时候不指定target，那么就会默认执行Process的run方法,那么执行时没有任何效果;
    # 因为默认的run方法是判断如果不指定target，那就什么都不做.

    print('Process will start.')
    befor_time = time.time()
    # p1.start()#启动子进程
    # p2.start()#启动子进程

    p_list = [p1,p2]
    # map(multiprocessing.Process.start,p_list)
    for p in p_list:#此处联想到多线程，python中使用threading模块创建多线程t = threading.Thread(target=run)
        # p.daemon() 设置守护进程方式
        # t.setDaemon(True) 设置守护线程方式 守护线程和守护进程之间是有区别的
        p.start()

    for j in p_list:
        j.join()

    # p1.join()#设置主进程阻塞(阻塞当前进程),直到调用join方法的那个进程执行完，再继续执行当前进程。
    # p2.join()#设置主进程阻塞(阻塞当前进程),直到调用join方法的那个进程执行完，再继续执行当前进程。
    print('have done!!!')
    after_time = time.time()
    print(after_time - befor_time)#used time 3.1761817932128906

    '''=================================进程池==================================='''
    pool = multiprocessing.Pool(processes=5)#表示这个进程池中将有5个进程
    for i in range(3):
        print(i)
        pool.apply_async(func1, ("hello %d" % (i),))
        # pool.apply(func, ("hello %d" %(i), ))
    pool.close() #close方法：说关闭进程池，至此，进程池中不在有进程可以接受任务。
    # pool.terminate() #结束工作进程，不在处理未完成的任务
    pool.join()  # 主进程阻塞，等待子进程的退出， join方法要在close或terminate之后使用
    #terminate和join是一对方法，表示的内容截然相反，执行terminate是结束当前进程池中的所有进程，
    # 不管值没执行完。join方法是阻塞主进程，等待子进程执行完毕，再继续执行主进程。
    # 需要注意的是：这两个方法都必须在close方法之后执行。当然我们也可以不执行这两个方法，那么
    # 子进程和主进程就各自执行各自的，无论执行到哪里，子进程会随着主进程的结束而结束。。。
    print("fuck off.")

转载于:https://www.cnblogs.com/BinZhou0901/p/10559814.html