python :进程简介,进程管理

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

    进程简介

    • 什么是进程(任务)?
      • 在计算机中,一个进程就是一个任务,其实就是运行着的程序。
      • 在操作系统中,进程就是程序执行和资源分配的基本单元。
    • 单核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('主进程结束')

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

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

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