python进程间通讯 python多进程通信

转载

数据探索先锋 2023-06-30 22:32:55

文章标签 python进程间通讯 python 多进程队列多线程 文章分类 Python 后端开发

python多进程及进程间通信

0 简述
1 多进程的使用

1.1 导入进程包
1.2 Process进程类的说明
1.3 多进程完成多任务的代码

2 获取进程编号

2.1 获取当前进程编号
2.2 获取当前父进程编号

3 进程执行带有参数的任务

3.1 进程执行带有参数的任务的介绍
3.2 args参数的使用
3.3 kwargs参数的使用

4 进程的注意点

4.1 进程之间不共享全局变量
4.2 主进程会(默认)等待所有的子进程执行结束再结束，但是也可以使用join

5 其他多进程的实现方式（以后展开）

5.1 继承Process类创建子进程
5.2 进程池（重点，待编写）
5.3 os.fork()

6 进程间通信

6.1 队列实现进程间的通信
6.2 管道实现进程间通信

0 简述

Process 类的实例常用的属性和方法有：

属性/方法	说明
name	当前进程实例的别名，默认为 Process-N，N 为从 1 开始递增的整数
pid	当前进程实例的 PID 值
is_alive()	判断进程实例是否还在执行
join([timeout])	是否等待进程实例执行结束，或等待多少秒
start()	启动进程实例（创建子进程）
run()	如果没有给定 target 参数，对这个对象调用 start() 方法时，就将执行对象中的 run() 方法
terminate()	不管任务是否完成，立即终止

1 多进程的使用

1.1 导入进程包

#导入进程包
import multiprocessing

1.2 Process进程类的说明

Process([group [, target [, name [, args [, kwargs]]]]])

group：指定进程组，目前只能使用None
target：执行的目标任务名
name：进程名字
args：以元组方式给执行任务传参
kwargs：以字典方式给执行任务传参

Process创建的实例对象的常用方法:

start()：启动子进程实例（创建子进程）
join()：等待子进程执行结束
terminate()：不管任务是否完成，立即终止子进程

Process创建的实例对象的常用属性:

name：当前进程的别名，默认为Process-N，N为从1开始递增的整数

1.3 多进程完成多任务的代码

import multiprocessing
import time


# 跳舞任务
def dance():
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)


# 唱歌任务
def sing():
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果：

唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...
唱歌中...
跳舞中...

2 获取进程编号

2.1 获取当前进程编号

os.getpid() 表示获取当前进程编号

【注意】：
1 要先import os
2 Python中查看函数的命令是help，查看对象说明是dir
如：dir（os），help（os.getpid），函数后的括号不能带

示例代码：

import multiprocessing
import time
import os


#跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


#唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

  	 # 获取当前进程的编号
  	 print("main:", os.getpid())
  	 # 获取当前进程
  	 print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果：

main: 70763
main: <_MainProcess(MainProcess, started)>
dance: 70768
dance: <Process(myprocess1, started)>
跳舞中...
sing: 70769
sing: <Process(Process-2, started)>
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

几个注意的点：
1 os.kill（）函数：kill(pid, signal, /)，无返回值

2 os.getpid() 函数：返回进程ID，是一个整数

3 multiprocessing.current_procecss() 函数：返回的是当前进程的进程对象。

2.2 获取当前父进程编号

os.getppid() 表示获取当前父进程编号

import multiprocessing
import time
import os


# 跳舞任务
def dance():
    # 获取当前进程的编号
    print("dance:", os.getpid())
    # 获取当前进程
    print("dance:", multiprocessing.current_process())
    # 获取父进程的编号
    print("dance的父进程编号:", os.getppid())
    for i in range(5):
        print("跳舞中...")
        time.sleep(0.2)
        # 扩展:根据进程编号杀死指定进程
        os.kill(os.getpid(), 9)


# 唱歌任务
def sing():
    # 获取当前进程的编号
    print("sing:", os.getpid())
    # 获取当前进程
    print("sing:", multiprocessing.current_process())
    # 获取父进程的编号
    print("sing的父进程编号:", os.getppid())
    for i in range(5):
        print("唱歌中...")
        time.sleep(0.2)


if __name__ == '__main__':

    # 获取当前进程的编号
    print("main:", os.getpid())
    # 获取当前进程
    print("main:", multiprocessing.current_process())
    # 创建跳舞的子进程
    # group: 表示进程组，目前只能使用None
    # target: 表示执行的目标任务名(函数名、方法名)
    # name: 进程名称, 默认是Process-1, .....
    dance_process = multiprocessing.Process(target=dance, name="myprocess1")
    sing_process = multiprocessing.Process(target=sing)

    # 启动子进程执行对应的任务
    dance_process.start()
    sing_process.start()

执行结果：

main: 70860
main: <_MainProcess(MainProcess, started)>
dance: 70861
dance: <Process(myprocess1, started)>
dance的父进程编号: 70860
跳舞中...
sing: 70862
sing: <Process(Process-2, started)>
sing的父进程编号: 70860
唱歌中...
唱歌中...
唱歌中...
唱歌中...
唱歌中...

3 进程执行带有参数的任务

3.1 进程执行带有参数的任务的介绍

前面我们使用进程执行的任务是没有参数的，假如我们使用进程执行的任务带有参数，如何给函数传参呢?

Process类执行任务并给任务传参数有两种方式:

args 表示以元组的方式给执行任务传参
kwargs 表示以字典方式给执行任务传参

3.2 args参数的使用

示例代码:

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程
    # args: 以元组的方式给任务传入参数
    sub_process = multiprocessing.Process(target=task, args=(5,))
    sub_process.start()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行中..
任务执行完成

3.3 kwargs参数的使用

示例代码

import multiprocessing
import time


# 带有参数的任务
def task(count):
    for i in range(count):
        print("任务执行中..")
        time.sleep(0.2)
    else:
        print("任务执行完成")


if __name__ == '__main__':
    # 创建子进程

    # kwargs: 表示以字典方式传入参数
    sub_process = multiprocessing.Process(target=task, kwargs={"count": 3})
    sub_process.start()

执行结果：

任务执行中..
任务执行中..
任务执行中..
任务执行完成

4 进程的注意点

4.1 进程之间不共享全局变量

import multiprocessing
import time

# 定义全局变量
g_list = list()


# 添加数据的任务
def add_data():
    for i in range(5):
        g_list.append(i)
        print("add:", i)
        time.sleep(0.2)

    # 代码执行到此，说明数据添加完成
    print("add_data:", g_list)


def read_data():
    print("read_data", g_list)


if __name__ == '__main__':
    # 创建添加数据的子进程
    add_data_process = multiprocessing.Process(target=add_data)
    # 创建读取数据的子进程
    read_data_process = multiprocessing.Process(target=read_data)

    # 启动子进程执行对应的任务
    add_data_process.start()
    # 主进程等待添加数据的子进程执行完成以后程序再继续往下执行，读取数据
    add_data_process.join()
    read_data_process.start()

    print("main:", g_list)

    # 总结: 多进程之间不共享全局变量

执行结果：

add: 0
add: 1
add: 2
add: 3
add: 4
add_data: [0, 1, 2, 3, 4]
main: []
read_data []

进程之间不共享全局变量的解释图：

python进程间通讯 python多进程通信_python

创建子进程会对主进程资源进行拷贝，也就是说子进程是主进程的一个副本，好比是一对双胞胎，之所以进程之间不共享全局变量，是因为操作的不是同一个进程里面的全局变量，只不过不同进程里面的全局变量名字相同而已。

4.2 主进程会(默认)等待所有的子进程执行结束再结束，但是也可以使用join

示例1：

假如我们现在创建一个子进程，这个子进程执行完大概需要2秒钟，现在让主进程执行0.5秒钟就退出程序，查看一下执行结果，示例代码如下:

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    sub_process.start()

    # 主进程延时0.5秒钟
    time.sleep(0.5)
    print("over")
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出

执行结果：

任务执行中...
任务执行中...
任务执行中...
over
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...
任务执行中...

通过上面代码的执行结果，我们可以得知: 主进程会等待所有的子进程执行结束再结束。

假如我们要保证主进程不再等待子进程而结束，该怎么办呢。即如何保证主进程正常结束？

我们可以设置守护主进程 或者 在主进程退出之前让子进程销毁

守护主进程:

守护主进程就是主进程退出子进程销毁不再执行

子进程销毁:

子进程执行结束

示例：（1 设置守护进程）

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    # 设置守护主进程，主进程退出子进程直接销毁，子进程的生命周期依赖与主进程
    sub_process.daemon = True
    sub_process.start()

    time.sleep(0.5)
    print("over")
   
    exit()

    # 总结： 主进程会等待所有的子进程执行完成以后程序再退出
    # 如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

示例：（2销毁子进程）

import multiprocessing
import time


# 定义进程所需要执行的任务
def task():
    for i in range(10):
        print("任务执行中...")
        time.sleep(0.2)

if __name__ == '__main__':
    # 创建子进程
    sub_process = multiprocessing.Process(target=task)
    
    sub_process.start()

    time.sleep(0.5)
    print("over")
    # 让子进程销毁
    sub_process.terminate()
    exit()

总结：主进程会等待所有的子进程执行完成以后程序再退出
如果想要主进程退出子进程销毁，可以设置守护主进程或者在主进程退出之前让子进程销毁

示例二：

from multiprocessing import Process
from time import ctime,sleep
import os
def text(pause):
    for i in range(3):
        print('Child Process %s is running,at %s.' % (os.getpid(),ctime())) 
        sleep(pause)
if __name__ == '__main__':
    print('Main Process %s is running,at %s.' % (os.getpid(),ctime()))
    p = Process(target=text,args=(2,))
    p.start()
    if not p.is_alive():
        print('Main Process %s end,at %s.' % (os.getpid(),ctime()))

结果

Main Process 5540 is running,at Sat Aug 17 13:22:51 2019.
Child Process 1236 is running,at Sat Aug 17 13:22:52 2019.
Child Process 1236 is running,at Sat Aug 17 13:22:54 2019.
Child Process 1236 is running,at Sat Aug 17 13:22:56 2019.

分析：

我们用time模块下的sleep()函数让子进程休眠，用ctime()函数获取当前当地时间的字符串，可以看到，子进程不会结束，主进程也不会结束，主进程会默认等待子进程结束后其本身才会结束，这在一定程度上避免了僵尸进程的产生。

什么是僵尸进程呢，当子进程结束运行后会产生一个僵尸进程，它的作用是使进程退出，僵尸进程保存着进程的退出状态等信息，除此之外，僵尸进程不再占有任何内存空间。它需要父进程来回收这些信息，虽然父进程会默认等待子进程结束并回收资源后本身才会结束，但是如果父进程出现了其它异常情况，这就有可能造成僵尸进程继续残留，大量的僵尸进程积累会使内存空间被挤占。

这时有必要使用join()函数，join()函数会使主进程等待子进程，并且join()函数内部也有一个清除僵尸进程的函数可以用来回收资源；另外，如果有多条子进程被创建，那么start()函数也能够回收之前的僵尸进程。

示例3：

from multiprocessing import Process
a = 777
def text():
    global a
    a = 666
    print('Child Process,a = %d.' % (a))
if __name__ == '__main__':
    p = Process(target=text)
    p.start()
    p.join()
    print('Main Process,a = %d.' % (a))

Child Process,a = 666.
Main Process,a = 777.

分析：
在text()函数中，我们设置了一个全局变量a，但是可以看到即便如此父进程和子进程的a仍然是不同的，这说明进程之间的内存空间是隔离的，进程与进程之间相互独立。

5 其他多进程的实现方式（以后展开）

5.1 继承Process类创建子进程

5.2 进程池（重点，待编写）

进程池函数Pool()可以用来批量创建子进程，也可以用来管理进程。
进程池实际上是multiprocessing模块下的Pool类。

5.3 os.fork()

只能用于Unix系统！

6 进程间通信

Python 的 multiprocessing 模块包装了底层的机制，提供了 Queue（队列）、Pipes（管道）等多种方式来交换数据。

Queue和Pipes都是multiprocessing模块/包（文件）中的一个类。

6.1 队列实现进程间的通信

队列（Queue）就是模仿现实中的排队，最前面的最先走，后面来的排在最后面，如图所示：

python进程间通讯 python多进程通信_python_02

Queue是multiprocessing模块/包（本质上是文件）中的一个类。

队列的初始化：q = Queue(num)若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接收的消息数量没有上限（直到内存的尽头）。

Queue 的常用方法如下所示：（这里先把Queue看作是Queue类的一个对象）

方法	说明
Queue.qsize()	返回当前队列包含的消息数量
Queue.empty()	如果队列为空，返回 True，否则返回 False
Queue.full()	如果队列满了，返回 True，否则返回 False
Queue.get([block[, timeout]])	获取队列中的一条消息，然后将其从队列中移除，block 默认值为 True。如果 block 使用默认值，且没有设置 timeout（单位：秒），消息队列为空，此时程序将被阻塞（停在读取状态），直到从消息队列读到消息为止，如果设置了 timeout，则会等待 timeout 秒，若还没有读取到任何消息，则抛出 Queue.Empty 异常
Queue.get_nowait()	相当于 Queue.get(False)
Queue.put(item, [block[, timeout]])	将 item 消息写入队列，block 默认值为 True。如果 block 使用默认值，且没有设置 timeout（单位：秒），消息队列如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息队列腾出空间为止，如果设置了 timeout，则会等待 timeout 秒，若还没有空间，则抛出 Queue.full 异常
Queue.put_nowait(item)	相当于 Queue.put(item, False)

示例：

from multiprocessing import Queue

if __name__ == '__main__':
    q = Queue(3)    # 初始化一个 Queue 对象，最多可接收 3 条 put 消息
    q.put("消息1")
    q.put("消息2")
    print(q.full())
    q.put("消息3")
    print(q.full())

    # 因为消息队列已满，再 put 会报异常，第一个 try 等待 2 秒后再抛出异常，第二个 try 立刻抛出
    try:
        q.put("消息4", True, 2)
    except:
        print("消息队列已满，现有消息数量: %s" % q.qsize())

    try:
        q.put_nowait("消息4")
    except:
        print("消息队列已满，现有消息数量: %s" % q.qsize())

    # 读取消息时，先判断消息队列是否为空，再读取
    if not q.empty():
        print("----从消息队列中获取消息--")
        for i in range(q.qsize()):
            print(q.get_nowait())

下面通过一个实例结合 Process 和 Queue 实现进程间通信。创建两个子进程，一个子进程负责向队列中写入数据，另一个子进程负责从队列中读取数据。

from multiprocessing import Process, Queue
import time

# 向对列中写入数据
def write_task(q):
    if not q.full():
        for i in range(5):
            message = "消息" + str(i)
            q.put(message)
            print("写入: %s" % message)

# 从队列读取数据
def read_task(q):
    time.sleep(1)// 目的是等待write进程结束
    while not q.empty():
        print("读取: %s" % q.get(True, 2))    # 等待 2 秒，如果还没有读取到任何消息，则抛出异常

if __name__ == '__main__':
    print("---父进程开始---")
    q = Queue()     # 父进程创建 Queue，并传递给子进程
    pw = Process(target=write_task, args=(q,))
    pr = Process(target=read_task, args=(q,))
    pw.start()
    pr.start()

    print("---等待子进程结束---")
    pw.join()
    pr.join()
    print("---父进程结束---")

结果：

---父进程开始---
---等待子进程结束---
写入: 消息0
写入: 消息1
写入: 消息2
写入: 消息3
写入: 消息4
读取: 消息0
读取: 消息1
读取: 消息2
读取: 消息3
读取: 消息4
---父进程结束---

6.2 管道实现进程间通信

multiprocessing.Pipe()即管道模式，调用Pipe()返回管道的两端的Connection对象。
当主进程创建Pipe的时候，Pipe的两个Connections连接的的都是主进程。
当主进程创建子进程后，Connections也被拷贝了一份。此时有了4个Connections。
此后，关闭主进程的一个Out Connection，关闭一个子进程的一个In Connection。那么就建立好了一个输入在主进程，输出在子进程的管道。

# 示例代码
# coding=utf-8
from multiprocessing import Pipe, Process
 
 
def son_process(x, pipe):
    _out_pipe, _in_pipe = pipe
 
    # 关闭fork过来的输入端
    _in_pipe.close()
    while True:
        try:
            msg = _out_pipe.recv()
            print msg
        except EOFError:
            # 当out_pipe接受不到输出的时候且输入被关闭的时候，会抛出EORFError，可以捕获并且退出子进程
            break
 
 
if __name__ == '__main__':
    out_pipe, in_pipe = Pipe(True)
    son_p = Process(target=son_process, args=(100, (out_pipe, in_pipe)))
    son_p.start()
 
    # 等pipe被fork 后，关闭主进程的输出端
    # 这样，创建的Pipe一端连接着主进程的输入，一端连接着子进程的输出口
    out_pipe.close()
    for x in range(1000):
        in_pipe.send(x)
    in_pipe.close()
    son_p.join()
    print "主进程也结束了"

总结一下：

上面的代码中主要用到了pipe的send()、recv()、close()方法。当pipe的输入端被关闭，且无法接收到输入的值，那么就会抛出EOFError。

新建一个Pipe(duplex)的时候，如果duplex为True，那么创建的管道是双向的；如果duplex为False，那么创建的管道是单向的。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。