一、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]]]]]) ，由该类实例化得到的对象，表示一个子进程中的任务（尚未启动）

强调：

需要使用关键字的方式来指定参数
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

您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请用微信扫描下面二维码支持博主2元、5元、10元、20元等您想捐的金额吧，狠狠点击下面给点支持吧，站长非常感激您！手机微信长按不能支付解决办法：请将微信支付二维码保存到相册，切换到微信，然后点击微信右上角扫一扫功能，选择支付二维码完成支付。

【本文对您有帮助就好】元

2元

5元

10元

20元

自定义