python基础(16)-python中的进程操作

multiprocess模块

Process(进程)

Process模块是一个创建进程的模块,借助这个模块,就可以完成进程的创建。

  • 介绍

    • 初始化参数
      Process([group [, target [, name [, args [, kwargs]]]]]),由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)
      
      强调:
      1. 需要使用关键字的方式来指定参数
      2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号
      
      参数介绍:
      1 group参数未使用,值始终为None
      2 target表示调用对象,即子进程要执行的任务
      3 args表示调用对象的位置参数元组,args=(1,2,'egon',)
      4 kwargs表示调用对象的字典,kwargs={'name':'egon','age':18}
      5 name为子进程的名称
    • 方法
      p.start():启动进程,并调用该子进程中的p.run() 
      p.run():进程启动时运行的方法,正是它去调用target指定的函数,我们自定义类的类中一定要实现该方法  
      p.terminate():强制终止进程p,不会进行任何清理操作,如果p创建了子进程,该子进程就成了僵尸进程,使用该方法需要特别小心这种情况。如果p还保存了一个锁那么也将不会被释放,进而导致死锁
      p.is_alive():如果p仍然运行,返回True
      p.join([timeout]):主线程等待p终止(强调:是主线程处于等的状态,而p是处于运行的状态)。timeout是可选的超时时间,需要强调的是,p.join只能join住start开启的进程,而不能join住run开启的进程  
      
    • 属性
      p.daemon:默认值为False,如果设为True,代表p为后台运行的守护进程,当p的父进程终止时,p也随之终止,并且设定为True后,p不能创建自己的新进程,必须在p.start()之前设置
      p.name:进程的名称
      p.pid:进程的pid
      p.exitcode:进程在运行时为None、如果为–N,表示被信号N结束(了解即可)
      p.authkey:进程的身份验证键,默认是由os.urandom()随机生成的32字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)
    • 在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制),在创建子进程的时候会自动 import 启动它的这个文件,而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用if __name__ ==‘__main__’ 判断保护起来,import 的时候  ,就不会递归运行了。
  • 使用

    • 创建子进程
       1 import time
       2 from multiprocessing import Process
       3 
       4 
       5 def f(name):
       6     print('hello', name)
       7     print('我是子进程')
       8 
       9 
      10 if __name__ == '__main__':
      11     p = Process(target=f, args=('bob',))
      12     p.start()
      13     time.sleep(1)
      14     print('执行主进程的内容了')
      15 
      16 # result
      17 # hello bob
      18 # 我是子进程
      19 # 执行主进程的内容了
      View Code
    • join()

      join()函数可以阻塞主进程,让其等待子进程代码执行完毕后,再执行join()后面的代码

       1 import time
       2 from multiprocessing import Process
       3 
       4 
       5 def f(name):
       6     print('hello', name)
       7     time.sleep(2)
       8     print('我是子进程')
       9 
      10 
      11 if __name__ == '__main__':
      12     p = Process(target=f, args=('bob',))
      13     p.start()
      14     time.sleep(1)
      15     p.join()
      16     print('执行主进程的内容了')
      17 
      18 # result
      19 # hello bob
      20 # 我是子进程
      21 # 执行主进程的内容了
      View Code
    • 查看进程号
       1 import os
       2 from multiprocessing import Process
       3 
       4 def f(x):
       5     print('子进程id :',os.getpid(),'父进程id :',os.getppid())
       6     return x*x
       7 
       8 if __name__ == '__main__':
       9     print('主进程id :', os.getpid())
      10     p_lst = []
      11     for i in range(5):
      12         p = Process(target=f, args=(i,))
      13         p.start()
      14 
      15 #result:
      16 # 主进程id : 9208
      17 # 子进程id : 4276 父进程id : 9208
      18 # 子进程id : 3744 父进程id : 9208
      19 # 子进程id : 9392 父进程id : 9208
      20 # 子进程id : 3664 父进程id : 9208
      21 # 子进程id : 520 父进程id : 9208
      View Code
    • 执行多个子进程
       1 import time
       2 from multiprocessing import Process
       3 
       4 
       5 def f(name):
       6     print('hello', name)
       7     time.sleep(1)
       8 
       9 
      10 if __name__ == '__main__':
      11     p_lst = []
      12     for i in range(5):
      13         p = Process(target=f, args=('bob%s'%i,))
      14         p.start()
      15         p_lst.append(p)
      16     [p.join() for p in p_lst]
      17     print('父进程在执行')
      18 #result:
      19 # hello bob0
      20 # hello bob1
      21 # hello bob2
      22 # hello bob3
      23 # hello bob4
      24 # 父进程在执行
      View Code
    • 继承Process类开启进程
       1 import os
       2 from multiprocessing import Process
       3 
       4 
       5 class MyProcess(Process):
       6     def __init__(self, name):
       7         super().__init__()
       8         self.name = name
       9 
      10     def run(self):
      11         print(os.getpid())
      12         print(self.name)
      13 
      14 
      15 if __name__ == '__main__':
      16     p1 = MyProcess('p1')
      17     p2 = MyProcess('p2')
      18     p3 = MyProcess('p3')
      19     # start会自动调用run
      20     p1.start()
      21     p2.start()
      22     p3.start()
      23 
      24     p1.join()
      25     p2.join()
      26     p3.join()
      27     print('主线程111')
      28 
      29 #result:
      30 # 1740
      31 # p1
      32 # 8468
      33 # p2
      34 # 9572
      35 # p3
      36 # 主线程111
      View Code
    • 守护进程
       1 import time
       2 from multiprocessing import Process
       3 
       4 
       5 def func():
       6     while True:
       7         print('我还活着')
       8         time.sleep(0.5)
       9 
      10 
      11 if __name__ == "__main__":
      12     p = Process(target=func)
      13     p.daemon = True  # 设置子进程为守护进程
      14     p.start()
      15     i = 2
      16     while i > 0:
      17         print('主进程执行')
      18         time.sleep(1)
      19         i -= 1
      20     print('主进程执行完毕')
      21 
      22 # result
      23 # 主进程执行
      24 # 我还活着
      25 # 我还活着
      26 # 主进程执行
      27 # 我还活着
      28 # 我还活着
      29 # 主进程执行完毕
      守护进程
       1 import time
       2 from multiprocessing import Process
       3 
       4 
       5 def func():
       6     while True:
       7         print('我还活着')
       8         time.sleep(0.5)
       9 
      10 
      11 if __name__ == "__main__":
      12     p = Process(target=func)
      13     # p.daemon = True  # 设置子进程为守护进程
      14     p.start()
      15     i = 2
      16     while i > 0:
      17         print('主进程执行')
      18         time.sleep(1)
      19         i -= 1
      20     print('主进程执行完毕')
      21 
      22 # result
      23 # 主进程执行
      24 # 我还活着
      25 # 我还活着
      26 # 主进程执行
      27 # 我还活着
      28 # 我还活着
      29 # 主进程执行完毕
      30 # 我还活着
      31 # 我还活着
      32 # 我还活着
      33 # 我还活着
      34 # 我还活着
      35 # 我还活着
      36 # 我还活着
      37 # 我还活着
      38 # ...
      非守护进程

Lock(锁)

  • 使用

     1 from multiprocessing import Process
     2 import time
     3 import os
     4 
     5 
     6 def func():
     7     time.sleep(1)
     8     print('正在执行子进程的进程号:{},当前时间:{}'.format(os.getpid(), time.strftime("%Y-%m-%d %X")))
     9 
    10 
    11 if __name__ == '__main__':
    12     for i in range(5):
    13         Process(target=func).start()
    14 
    15 # result:
    16 # 正在执行子进程的进程号:6044,当前时间:2018-09-09 19:22:12
    17 # 正在执行子进程的进程号:7024,当前时间:2018-09-09 19:22:12
    18 # 正在执行子进程的进程号:9900,当前时间:2018-09-09 19:22:12
    19 # 正在执行子进程的进程号:8888,当前时间:2018-09-09 19:22:12
    20 # 正在执行子进程的进程号:10060,当前时间:2018-09-09 19:22:12
    未加锁
     1 from multiprocessing import Lock
     2 from multiprocessing import Process
     3 import time
     4 import os
     5 
     6 
     7 def func(lock):
     8     lock.acquire()
     9     time.sleep(1)
    10     print('正在执行子进程的进程号:{},当前时间:{}'.format(os.getpid(), time.strftime("%Y-%m-%d %X")))
    11     lock.release()
    12 
    13 
    14 if __name__ == '__main__':
    15     lock = Lock()
    16     for i in range(5):
    17         Process(target=func, args=(lock,)).start()
    18 
    19 # result:
    20 # 正在执行子进程的进程号:8752,当前时间:2018-09-09 19:25:39
    21 # 正在执行子进程的进程号:10152,当前时间:2018-09-09 19:25:40
    22 # 正在执行子进程的进程号:5784,当前时间:2018-09-09 19:25:41
    23 # 正在执行子进程的进程号:9708,当前时间:2018-09-09 19:25:42
    24 # 正在执行子进程的进程号:8696,当前时间:2018-09-09 19:25:43
    加锁

     

猜你喜欢

转载自www.cnblogs.com/zze46/p/9614671.html