进程

单任务现象

一个项目中，程序都是在主函数下一步一步执行的，这种现象称为单进程

import  time
def run():
    while True:
        print('子进程进行中')
        time.sleep(1.2)
if __name__ == '__main__':
    while True:
        print("主进程进行中")
        time.sleep(1)
    run()

主程序和run 不会同时执行

启动进程多任务

multiprocessing 库

该库是跨平台的多进程模块，提供了Processs类来代表了一个进程对象

from multiprocessing import Process
import time
import os
def run(str):
    while True:
        x = os.getpid()   #获取当前进程pid
        y = os.getppid()  #获取当前父进程的pid
        print(x)
        print(y)
        print('子进程进行中'+str)
        time.sleep(1.2)
if __name__ == '__main__':   #主函数
    print("主进程启动")
    #获取当前进程pid
    x = os.getpid()
    print(x)
    #创建一个子进程
    #target 说明进程执行的函数
    #args  给子进程对象传送的参数 要以元组的形式
    p = Process(target=run, args=("nice",))
    p.start()   #启子进程对象
    while True:
        print("主进程进行中")
        time.sleep(1)

用进程池启动大量子进程

multiprocessing 该库中有一个 Pool 
Pool 是进程池，进程池中的进程进行没有先后顺序
创建进程池 p = Pool（4）  表示可以同时执行的进程 默认是核心数
p.clos 关闭进程池 
p.join() 主程序阻塞 ，等待子程序结束

from multiprocessing import Pool
import os
import time
import random
def run(name):
    print("子进程%s开始----%s"%(name,os.getpid()))
    start = time.time()
    time.sleep(random.choice(range(5)))
    end = time.time()
    print("子进程%d结束----%s---耗时%2f" %(name, os.getpid(), end-start))

if __name__ == "__main__":
    print("父进程启动")
    #创建多个进程
    #进程池
    #表示可以同时执行的进程
    #Pool 默认时cpu核心数
    #p.apply_async(run,args=(i,)) 将进程加入进程池
    pp = Pool(4)
    for i in range(5):
        #创建进程 放入进程池 统一管理
        pp.apply_async(run,args=(i,))
    #再调用join之前必须先调用 close 且调用close后不能添加进程了
    pp.close()
    #进程池对象调用的join，对等待进程池中所有的子进程都结束后在执行父进程
    pp.join()
    print("父进程结束")

全局变量在多个进程中不能共享

子进程通过 global 修改全局变量，在主程序中不起作用

from multiprocessing import Process
import time
num = 100
def run():
    print("子进程开始")
    global num
    num += 1
    print(num)
    print("子进程结束")
if __name__ == "__main__":
    print("父进程开始")
    p = Process(target=run)
    p.start()
    p.join()
    #在子进程中修改全局变量对父进程没有影响
    #在创建子进程时对全局变量做了备份 父进程中的num和子进程中的num不一样
    print(num)

父子进程的先后顺序

from multiprocessing import Process
import time
import os
def run(str):
    print("紫禁城开始")
    time.sleep(3)
    print("紫禁城结束")
if __name__ == '__main__':
    print("主进程启动")
    p = Process(target=run)
    p.start()
    print("父进程结束")
    '''
    父进程的结束不能影响子进程
    '''
    p.join()  #等待子进程结束后 父进程再往下执行

进程间的通信

from multiprocessing import Process ,Queue
import os ,time
def write(q):
    print("启动子进程%s" % (os.getpid()))
    for x in ["A", "B", "C", "D"]:
        q.put(x)
        time.sleep(1)
    print('子进程结束%s' % os.getpid())
def read(q):
    print("启动子进程 %s" % os.getpid())
    while True:
        value = q.get(True)
        print('value=' + value)
    print("结束子进程%s" % os.getpid())
if __name__ == "__main__":
    #父进程创建队列,并传递给子进程
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    pw.start()
    pr.start()
    pw.join()
    #pr进程是个死循环，无法等待其结束，只能强行结束
    pr.terminate()
    print("父进程结束")
    while True:
        pass

进程对象的封装

封装py

from multiprocessing import Process
import time
import os
class jiuzhu(Process):
    def __init__(self, name):
        Process.__init__(self)
        self.name = name
    def run(self):
        print("子进程%s启动-----PID:%s" % (self.name, os.getpid()))
        start = time.time()
        '''
        子进程功能
        '''
        end = time.time()
        print("子进程%s结束-----PID:%s----用时%d秒" % (self.name, os.getpid(),end - start))

主函数

if __name__ == '__main__':
    print("主进程开始")

    #创建导入的某一功能子进程
    p = jiuzhu("name")
    #自动调用子进程
    p.start()
    p.join()
    print("主进程结束")