运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的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,))
      p2 = Process(target=foo,))
      p3 = Process(target=foo,))
      # 开启进程
      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,))
      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,))
    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)