python :进程简介,进程管理

进程简介

• 什么是进程(任务)？
  • 在计算机中，一个进程就是一个任务，其实就是运行着的程序。
  • 在操作系统中，进程就是程序执行和资源分配的基本单元。
• 单核CPU实现多任务
  • 将CPU的时间快速的切换和分配到不同的任务上
  • 若频率足够高，切换足够快，人的感官就无法感知
• 多核CPU实现多任务
  • 如果任务数量不超过CPU数量，完全可以一个核心做一件事
  • 在操作系统中几乎是不可能，通常任务数量都远远大于CPU数量
  • 同样可以采用轮流分配的方式实现多任务，只是同事干活的'人'是多个罢了
• 为什么使用多进程？
  • 在一个程序中，若出现耗时操作，程序就会出现阻塞(假死)，为了解决这种问题可以采用多进程进行解决。如：主进程负责管理工作，子进程负责做耗时操作。

进程管理

• 简单示例：

  import os
  import multiprocessing
  import time
  ​
  def do_something(*args, **kwargs):
      print('子进程开始')
      # 获取当前进程
      current_process = multiprocessing.current_process()
      print(current_process.pid, current_process.name)
      # 获取当前进程及父进程ID
      print(os.getpid(), os.getppid())
      print('args:', args)
      print('kwargs:', kwargs)
      time.sleep(5)
      print('子进程结束')
      
  # 启动子进程后，系统会拷贝当前代码并加载执行
  # 创建并启动子进程操作将无限循环进行下去
  # 放在下面的结构中可以解决这个问题
  if __name__ == '__main__':
      print('主进程开始')
      # 获取当前进程号
      print(os.getpid())
      # 获取当前进程
      current_process = multiprocessing.current_process()
      print('进程ID：', 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
      p.daemon = True
  ​
      # 启动进程
      p.start()
  ​
      # 等待子进程结束
      # p.join()
      time.sleep(1)
  ​
      # 手动结束子进程
      p.terminate()
  ​
      print('主进程结束')    

• 进程锁：限制资源只能被一个进程使用

  import multiprocessing
  import time
  from random import random
  ​
  def loop(lock):
      # 获取锁
      lock.acquire()
  ​
      current_process = multiprocessing.current_process()
      print(current_process.name, '开始')
      time.sleep(random() * 5)
      print(current_process.name, '结束')
      # 释放锁
      lock.release()   
      
  if __name__ == '__main__':
      # 创建一个进程锁
      lock = multiprocessing.Lock()
  ​
      lt = []
      for i in range(1, 6):
          p = multiprocessing.Process(target=loop, args=(lock,), name='子进程'+str(i))
          lt.append(p)
          p.start()
  ​
      for p in lt:
          p.join()

• 信号量：限制某个资源最多可以被多少个进行同时使用

  import multiprocessing
  import random
  import time
  ​
  def run(name, se):
      # 获取信号量
      se.acquire()
      print(name, '进程开始')
      time.sleep(random.random()*3)
      print(name, '进程结束')
      # 释放信号量
      se.release()     
   
  if __name__ == '__main__':
      # 创建一个信号量对象，需要指定上限
      se = multiprocessing.Semaphore(3)
      for i in range(1, 10):
          p = multiprocessing.Process(target=run, args=('num'+str(i), se))
          p.start()   

• 进程池

  import multiprocessing
  import random
  import time
  ​
  # 进程任务结束的回调函数，参数时进程函数的返回值
  def callback(num):
      print(num, '进程回调函数')
  ​
  def task(num):
      print(num, '开始')
      t = random.random() * 3
      time.sleep(t)
      print(num, '进程执行了{}秒'.format(t))
      print(num, '结束')
      return num   
  ​
  if __name__ == '__main__':  
      print('主进程开始')
      # 获取CPU核心数
      cpu_count = multiprocessing.cpu_count()
      # print(cpu_count)
      # 创建进程池：容量一般不超过CPU核心数
      pool = multiprocessing.Pool(cpu_count)
      # 循环创建进程，然后添加到进程池
      for i in range(1, 6):
          # 向进程池添加进程
          # func：进程任务，一个函数
          # args：以元组形式传递给进程函数的参数
          # kwargs：以字典形式传递给进程函数的参数
          pool.apply_async(func=task, args=(i,), callback=callback)
      # 关闭进程池，之后就不能再添加进程了
      pool.close()
      # 等待进程池结束
      pool.join()
      print('主进程结束')