python进程管理

    Python编程 wuya 23次浏览 已收录 0个评论

    进程管理

    • 简单示例:
      import multiprocessing
      import os
      import time
      
      def do_something(*args, **kwargs):
          print('子进程启动')
          # 获取当前进程
          current_process = multiprocessing.current_process()
          print(current_process.pid, current_process.name)
          print('子进程ID', os.getpid())
          print('父进程ID', os.getppid())
          print(args)
          print(kwargs)
          time.sleep(2)
          print('子进程结束')    
       
      # 启动子进程后,系统会拷贝当前代码并加载执行,若进程创建及启动继续执行则会无限循环下去,造成错误
      # 放在下面的结构中可以解决此问题
      if __name__ == '__main__':
          print('主进程启动')
          # 获取进程ID
          print('PID:', os.getpid())
      
          # 获取当前进程
          current_process = multiprocessing.current_process()
          print('进程唯一标识PID', current_process.pid)
          print('进程名:', current_process.name)
      
          # 创建子进程
          # target:指定进程任务,一个函数
          # name:指定进程的名字
          # args:元组,传递个进程函数的参数
          # kwargs:字典,传递给进程函数的参数
          p = multiprocessing.Process(target=do_something, args=(1, 2, 3), kwargs={'age': 18}, name='LoopProcess')
      
          # 设置子进程是否随父进程结束而结束,默认为False,不随主进程结束
          # 若主进程结束,子进程仍在运行,这样的子进程称为孤儿进程,守护进程(init)会接管这些进程
          p.daemon = True
      
          # 启动进程
          p.start()
      
          # 等待子进程结束
          # p.join()
      
          # 手动结束子进程
          # p.terminate()
      
          print('主进程结束')
    • 进程锁
      import multiprocessing
      import time
      import random
      
      def loop(lable, lock):
          # 获取锁
          lock.acquire()
          # 中间执行的操作为原子操作,不会被打断
          print(lable, '开始')
          time.sleep(random.random() * 2)
          print(lable, '结束')
          # 释放锁
          lock.release()    
      
      if __name__ == '__main__':
          print('主进程开始')
          # 创建进程锁
          lock = multiprocessing.Lock()
      
          lt = []
          for i in range(1, 6):
              p = multiprocessing.Process(target=loop, args=('子进程'+str(i), lock))
              lt.append(p)
              p.start()
      
          for p in lt:
              p.join()
      
          print('主进程结束')
    • 进程池
      import multiprocessing
      import random
      import time
      
      def huidiao(num):
          # num参数是进程任务函数的返回值
          print(num, '回调函数执行')
      
      def task(num):
          print(num, '开始')
          t = random.random() * 5
          time.sleep(t)
          print('{} 结束,执行了 {} 秒'.format(num, t))
          return num   
      
      if __name__ == '__main__':
          print('主进程开始')
          cpu_count = multiprocessing.cpu_count()
          # print('CPU核心数:', cpu_count)
          # 创建进程池,进程池的容量一般不超过CPU核心数
          pool = multiprocessing.Pool(cpu_count)
          # 循环添加进程
          for i in range(5):
              # func:进程任务,一个函数
              # args:元组形式的进程函数参数
              # kwargs:字典形式的进程函数参数
              # callback:进程结束时的回调函数
              pool.apply_async(func=task, args=(i+1,), callback=huidiao)
              
          # 关闭进程池,关闭后就不能再添加进程了
          pool.close()
          # 等待进程池结束(进程池中的所有进程结束)
          pool.join()
          print('主进程结束')

    学海无涯 , 版权所有丨如未注明 , 均为原创丨转载请注明python进程管理
    喜欢 (0)
    发表我的评论
    取消评论
    表情 加粗 删除线 居中 斜体 签到

    Hi,您需要填写昵称和邮箱!

    • 昵称 (必填)
    • 邮箱 (必填)
    • 网址