python进程管理

进程管理

• 简单示例：

  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