标签：运行   代码块   操作   for   process类   输出   shu   程序   rom   

进程模块multiprocessing

进程的创建 -用Process

• 注册进程Precess类

    #导入Process类
    from multiprocessing import Process
  
    #创建一个函数
    def fun():pass   
    #将这个函数的运行注册进一个新的进程中
    p = Process(target=fun) #注册进程，传入的是地址
    p.start()   #开始这个进程

  进程号的查看 -os.getpid() -os.getppid()

• 查看进程的进程号os.getpid()

    import os
    from multiprocessing improt Process
    #创建一个函数，获取这个进程的进程号
    def func():
        print(‘子进程：‘os.getpid())
  
    p = Process(target=fun) #注册进程
    p.start #开始进程
    print(‘父进程： ‘, os.getpid()) #打印主进程的进程号
  
    #结果
    子进程： 1234
    父进程： 6789

• 查看父进程os.getppid()

    import os
    from multiprocessing improt Process
    #创建一个函数，获取这个进程的进程号
    def func():
        print(‘子进程的父进程：‘os.getpiid())
  
    p = Process(target=fun) #注册进程
    p.start #开始进程
    print(‘父进程的父进程： ‘, os.getpiid())    #打印主进程的进程号
  
    #结果
    子进程的父进程： 6789   #当前进程 
    父进程的父进程： 1470   #pycharm运行的进程

  给进程传入参数 -args=(tuple)

• 新进程给函数传参数

    ‘‘‘注册进程‘‘‘
    from multiprocessing import Process
    def fun(args):pass      #函数需要传入一个参数 
  
    p = Process(target=fun, args=(canshu1,))    #给args传入就行，但是传入的是一个元祖   
  
    p.start()   #开始这个进程

进程的开始结束 -主进程和子进程的存活关系

• 默认情况下

  • 个进程互不干扰，主进程的结束不影响子进程的结束

      import time
      from multiprocessing import Process
      def fun():
          time.sleep(3)
          print(‘子进程结束‘)
      if __name__ == ‘__main__‘:  #启动进程必须判断这个
          p = Process(target=fun)
          p.start()
    
          print(‘主进程结束‘)
      #结果
      主进程结束
      子进程结束

• join()待子进程结束后程序继续进行

    import time
    from multiprocessing import Process
    def fun():
        print(1234)
        time.sleep(3)
    if __name__ == ‘__main__‘:    
        p = Process(target=fun)
        p.start()
        p.join()    #这里是子进程的结束位置，父进程等待子进程结束后继续运行
        print(‘您好‘)
    #结果
    1234
    您好  #停顿3秒后您好才被显示出来

  开始多个子进程

• 开始多个子进程

    from multiprocessing import Process
    def fun(num):
        print(‘进程{}正在运行‘.format(num))
  
    if __name__ == ‘__main__‘:  
        for i in range(3):
            p = Process(target=fun, i)
            p.start()
    #结果
    进程0正在运行
    进程1正在运行
    进程2正在运行

• 等待全部子进程结束后运行下面的代码

    from multiprocessing import Process
    def fun(num):
        print(‘进程{}正在运行‘.format(num))
  
    if __name__ == ‘__main__‘:
        p_list = []
        for i in range(3):
            p = Process(target=fun, i)
            p_list.append(p)
            p.start()
        [p.join() for p in p_list]  #关键之处
        prnt(‘所有的子进程全部结束‘)
    #结果 #__结果的输出进程不一定是按照顺序输出的__
    进程2正在运行
    进程0正在运行
    进程1正在运行
    所有的子进程全部结束

  利用类创建进程

    from multiprocessing import Process
    import os
    class MyProcess(Process):
        def __init__(self, arg1, arg2):
            super().__init__()  #必须继承父类的__init__()
            self.arg1 = arg1
            self.arg2 = arg2
  
        def run(self):  #必须有一个run()方法
            print(os.getpid())
    if __name__ == ‘__main__‘:
        p = MyProcess()
        p.start()       #调用run()方法

多进程之间的数据隔离问题

• 父进程和子进程之间的数据是隔离开的

守护进程

• 子进程-->守护进程 -设置daemon = True
  • 守护进程:主进程结束，守护进程强制被结束
  • 守护进程结束看主进程是否结束，不看其他子进程是否结束

进程类的其他方法及其属性

方法

• p.is_alive() 检测子进程是否存在
• p.terminate() 结束一个子进程，并不是立即结束，需要操作系统响应
• p.start() 开始一个进程

属性

• p.name 查看进程的名字
• p.pid 查看进程号
• p.daemon = Ture 将进程转换成守护进程

进程锁 - lock模块 -涉及数据安全问题

• 给一段代码加锁之后只能被一个进程同时调用

    import lock
    lock = lock() 
  
    lock.acquire()  #钥匙
    ‘‘‘被加锁的代码块‘‘‘
    lock.release()  #上交钥匙

进程模块multiprocessing

标签：运行   代码块   操作   for   process类   输出   shu   程序   rom   

原文地址：https://www.cnblogs.com/liliudong/p/9732488.html