112 Python程序中的进程操作-开启多进

系统 101 0

目录

  • 一、multiprocess模块
  • 二、multiprocess.process模块
  • 三、Process类
    • 3.1 方法介绍
    • 3.2 属性介绍
    • 3.3 在windows中使用Process类的注意事项
  • 四、process类的使用
    • 4.1 创建并开启子进程的两种方式
    • 4.2 join方法
    • 4.3 查看主进程和子进程的进程号
    • 4.4 查看进程名和进程状态、设置进程名
    • 4.5 terminate结束子进程
    • 4.6 Process中的守护进程
  • 五、socket聊天并发实例
    • 5.1 使用多进程实现socket聊天并发-server端
    • 5.2 使用多进程实现socket聊天并发-client端

运行中的程序就是一个进程。 所有的进程都是通过它的父进程来创建的 。因此,运行起来的python程序也是一个进程,那么我们也可以在程序中再创建进程。多个进程可以实现并发效果,当我们的程序中存在多个进程的时候,在某些时候,就会让程序的执行速度变快。

在linux c语言中创建线程使用的fork函数,而Python就需要借助响应的模块

一、multiprocess模块

仔细说来,multiprocess不是一个模块而是python中一个操作、管理进程的包。 之所以叫multi是取自multiple的多功能的意思,在这个包中几乎包含了和进程有关的所有子模块。由于提供的子模块非常多,为了方便大家归类记忆,我将这部分大致分为四个部分:创建进程部分,进程同步部分,进程池部分,进程之间数据共享。

二、multiprocess.process模块

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

三、Process类

Process([group [, target [, name [, args [, kwargs]]]]]) ,由该类实例化得到的对象,表示一个子进程中的任务(尚未启动)

强调:

  1. 需要使用关键字的方式来指定参数
  2. args指定的为传给target函数的位置参数,是一个元组形式,必须有逗号

参数介绍:

  • group参数未使用,值始终为None
  • target表示调用对象,即子进程要执行的任务
  • args表示调用对象的位置参数元组, args=(1,2,'egon',)
  • kwargs表示调用对象的字典, kwargs={'name':'egon','age':18}
  • name为子进程的名称

3.1 方法介绍

  • 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开启的进程

3.2 属性介绍

  • 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字符的字符串。这个键的用途是为涉及网络连接的底层进程间通信提供安全性,这类连接只有在具有相同的身份验证键时才能成功(了解即可)

3.3 在windows中使用Process类的注意事项

在Windows操作系统中由于没有fork(linux操作系统中创建进程的机制),在创建子进程的时候会自动 import 启动它的这个文件,而在 import 的时候又执行了整个文件。因此如果将process()直接写在文件中就会无限递归创建子进程报错。所以必须把创建子进程的部分使用 if __name__ =='__main__' 判断保护起来,import 的时候,就不会递归运行了。

四、process类的使用

在一个python进程中开启子进程,start方法和并发效果。

4.1 创建并开启子进程的两种方式

  • 方式一:通过函数

                  
                    from multiprocessing import Process
    import time
    
    '''
    开启子进程的两种方式:
    1. 通过函数
    2. 通过类。继承Process
    '''
    
    def task(name):
        print("进程{%s} start"%(name))
        time.sleep(2)
        print(f"进程{name} end")
    
    # 必须加main
    if __name__ == '__main__':
        ######## 方式1(通过函数)
        p = Process(target=task,args=("xc",))   # args用于传参,是个元祖,必须加逗号
        p.start() # 告诉操作系统启动子进程,但一定是父进程先执行,多个子进程的执行顺序是根据操作系统调度决定的
        print('主进程/父进程')
        print('主进程/父进程')
        p1 = Process(target=task,args=("cyx",))
        p1.start()  # 告诉操作系统启动子进程,但一定是父进程先执行,多个子进程的执行顺序是根据操作系统调度决定的
        print('主进程/父进程')
        print('主进程/父进程')
        print('主进程/父进程')
        print('主进程/父进程')
                  
                
  • 方式二:通过类。继承Process

                  
                    from multiprocessing import Process
    import time
    
    '''
    开启子进程的两种方式:
    1. 通过函数
    2. 通过类。继承Process
    '''
    
    class myProcess(Process):
        def __init__(self,name):
            # self.name = name #错误 ### 这样没有给对象添加属性name,而是在修改父类的进程名(name)
    
            # 父类Process的进程名也是name
            super().__init__()  # 调用父类super().init方法完成创建进程初始化,重新给name属性赋值了。
            self.name = name    ## 在父类的init方法后设置name,才是为自己对象添加属性
    
            # super().__init__(name=name)  # 调用父类super().init,并设置进程名(name)
    
    
        def run(self):  # 创建进程会默认调用run方法
            print("进程%s start" % (self.name))
            time.sleep(2)
            print(f"进程{self.name} end")
    
    # 必须加main
    if __name__ == '__main__':
        p = myProcess("xc")
        p.start()
        print('主进程/父进程')
        print('主进程/父进程')
        p1 = myProcess("cyx")
        p1.start()  # 告诉操作系统启动子进程,但一定是父进程先执行,多个子进程的执行顺序是根据操作系统调度决定的
        print('主进程/父进程')
        print('主进程/父进程')
        print('主进程/父进程')
        print('主进程/父进程')
                  
                

4.2 join方法

join方法用于回收子进程

          
            from multiprocessing import Process
import time
  
def foo(x):
      print('进程  start ')
      time.sleep(x)
      print('进程  end ')
      
if __name__ == '__main__':
      ### 串行执行和回收子进程
      # p = Process(target=foo, args=(1,))
      # p2 = Process(target=foo, args=(2,))
      # p3 = Process(target=foo, args=(3,))
      # p.start() #
      # p.join() # 阻塞住主进程再等待子进程结束,然后再往下执行,(了解的是:内部会待用wait())
      # p2.start()
      # p2.join()
      # p3.start()
      # p3.join()
      # print('主')
  
      # 并发执行进程,并依次回收
      p = Process(target=foo, args=(1,))
      p2 = Process(target=foo, args=(2,))
      p3 = Process(target=foo, args=(3,))
      # 开启进程
      p.start()
      p2.start()
      p3.start()
  
      # 回收进程
      p.join() # 阻塞住主进程再等待子进程结束,然后再往下执行,(了解的是:内部会待用wait())
      p2.join()
      p3.join()
      print('主')
          
        

4.3 查看主进程和子进程的进程号

          
            from multiprocessing import Process,current_process
import time
import os
  
  '''
  查看主进程和子进程的进程号
  1. 通过os.getpid()方法
  2. 通过multiprocessing模块中的current_process().pid
  '''
  
  def task(name,x):
      print("当前进程pid:", current_process().pid)
      print(f"{name} start")
      time.sleep(x)
      print(f"{name} end")
  
  if __name__ == '__main__':
      p = Process(target=task,args=("进程1",1))
      p.start()
      # 方式一
      print("子进程pid:",p.pid)
      # 方式二
      # print("当前进程pid:",current_process().pid)
      print("当前进程pid",os.getpid())
      print("主进程的父进程pid",os.getppid())    # 实际上是pycharm的进程号
      print()
          
        

4.4 查看进程名和进程状态、设置进程名

          
            '''
process设置名字: name属性
process判断进程是否存在:is_alive
'''

from multiprocessing import Process
import time
  
  def task(x):
      print("进程 start")
      time.sleep(x)
      print("进程 end")
  
  if __name__ == '__main__':
      p = Process(target=task,args=(1,))
      p.start()
      p.name = "进程1"
      print(p.name)
  
      print("子进程是否存在:", p.is_alive()) # True
      time.sleep(2)   # 延时2秒等待子进程结束
      print("子进程是否存在:", p.is_alive()) # False
  
      print("主进程")
          
        

4.5 terminate结束子进程

          
            '''
terminate()
告诉子进程让他结束
'''

from multiprocessing import Process
import time
def task(x):
    print("进程 start")
    time.sleep(x)
    print("进程 end")

if __name__ == '__main__':
    p = Process(target=task,args=(10,))
    p.start()
    p.terminate()   # 告诉子进程让他提前结束

    p.name = "进程1"
    print(p.name)

    print("子进程是否存在:", p.is_alive()) # True
    p.join()
    print("子进程是否存在:", p.is_alive()) # False

    print("主进程")
          
        

4.6 Process中的守护进程

首先,博主自己测试,实验。Process中守护进程的部分和真正的守护进程概念并不一样,因此只需要知道Process的守护进程即可。

          
            '''
daemon = True 把子进程变为守护进程
主进程的代码执行完毕守护进程直接结束。但如果子进程代码结束也会结束
'''
from multiprocessing import Process
import time
def task(x):
    print("进程 start")
    time.sleep(x)
    print("进程 end")


if __name__ == '__main__':
    p = Process(target=task,args=(2,))
    p.daemon = True  # 把子进程变为守护进程
    p.start()
    # print(p.pid)

    p.name = "进程1"
    print(p.name)
    print("子进程pid:", p.pid) #

    print("子进程是否存在:", p.is_alive()) # True
    time.sleep(3)
    print("子进程是否存在:", p.is_alive()) # False

    print("主进程")
    print("子进程是否存在:", p.is_alive())  # False

    time.sleep(200)
          
        

五、socket聊天并发实例

5.1 使用多进程实现socket聊天并发-server端

          
            import socket
from multiprocessing import Process

def talk(conn,client_addr):
    while 1:
            msg = conn.recv(1024)
            if not msg:
                break
            print(msg.decode("utf8"))
            conn.send(msg.upper())
            print(111)

if __name__ == '__main__':
    # 必须要写在里面,不然会因为创建子线程重复调用导致端口被占用
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind(("127.0.0.1", 8087))
    server.listen(5)

    while 1:
        print("等待连接")
        conn,addr = server.accept()
        print(addr,"连接成功")
        p = Process(target=talk,args=(conn,addr))
        p.start()
          
        

5.2 使用多进程实现socket聊天并发-client端

          
            import socket

if __name__ == '__main__':
    client = socket.socket()
    client.connect(("127.0.0.1",8087))
    while 1:
        msg = input("请输入内容")
        client.send(msg.encode("utf8"))
        msg = client.recv(1024).decode("utf8")
        print(msg)
          
        

更多文章、技术交流、商务合作、联系博主

微信扫码或搜索:z360901061

微信扫一扫加我为好友

QQ号联系: 360901061

您的支持是博主写作最大的动力,如果您喜欢我的文章,感觉我的文章对您有帮助,请请扫描上面二维码支持博主1元、2元、5元等您想捐的金额吧,狠狠点击下面给点支持吧

发表我的评论
最新评论 总共0条评论