一文速通 Python 并行计算：10 Python 多进程编程-进程之间的数据共享-基于共享内存和数据管理器

摘要：

Python 多进程通信中，共享内存通过 Value 和 Array 实现高效数据共享，直接操作物理内存避免拷贝，需同步锁保证安全，支持数值、数组及自定义结构体（借助 ctypes 模块）。Manager 则通过服务进程管理共享对象（如 dict、list），支持更多数据类型但性能较低。共享内存适合高频小数据，Manager 适用于复杂数据结构，两者均需进程同步机制确保数据一致性，兼顾效率与灵活性。

关于我们更多介绍可以查看云文档：Freak 嵌入式工作室云文档，或者访问我们的 wiki：****https://github.com/leezisheng/Doc/wik

原文链接：

FreakStudio的博客

往期推荐：

学嵌入式的你，还不会面向对象？？！

全网最适合入门的面向对象编程教程：00 面向对象设计方法导论

全网最适合入门的面向对象编程教程：01 面向对象编程的基本概念

全网最适合入门的面向对象编程教程：02 类和对象的 Python 实现-使用 Python 创建类

全网最适合入门的面向对象编程教程：03 类和对象的 Python 实现-为自定义类添加属性

全网最适合入门的面向对象编程教程：04 类和对象的Python实现-为自定义类添加方法

全网最适合入门的面向对象编程教程：05 类和对象的Python实现-PyCharm代码标签

全网最适合入门的面向对象编程教程：06 类和对象的Python实现-自定义类的数据封装

全网最适合入门的面向对象编程教程：07 类和对象的Python实现-类型注解

全网最适合入门的面向对象编程教程：08 类和对象的Python实现-@property装饰器

全网最适合入门的面向对象编程教程：09 类和对象的Python实现-类之间的关系

全网最适合入门的面向对象编程教程：10 类和对象的Python实现-类的继承和里氏替换原则

全网最适合入门的面向对象编程教程：11 类和对象的Python实现-子类调用父类方法

全网最适合入门的面向对象编程教程：12 类和对象的Python实现-Python使用logging模块输出程序运行日志

全网最适合入门的面向对象编程教程：13 类和对象的Python实现-可视化阅读代码神器Sourcetrail的安装使用

全网最适合入门的面向对象编程教程：全网最适合入门的面向对象编程教程：14 类和对象的Python实现-类的静态方法和类方法

全网最适合入门的面向对象编程教程：15 类和对象的 Python 实现-__slots__魔法方法

全网最适合入门的面向对象编程教程：16 类和对象的Python实现-多态、方法重写与开闭原则

全网最适合入门的面向对象编程教程：17 类和对象的Python实现-鸭子类型与“file-like object“

全网最适合入门的面向对象编程教程：18 类和对象的Python实现-多重继承与PyQtGraph串口数据绘制曲线图

全网最适合入门的面向对象编程教程：19 类和对象的 Python 实现-使用 PyCharm 自动生成文件注释和函数注释

全网最适合入门的面向对象编程教程：20 类和对象的Python实现-组合关系的实现与CSV文件保存

全网最适合入门的面向对象编程教程：21 类和对象的Python实现-多文件的组织：模块module和包package

全网最适合入门的面向对象编程教程：22 类和对象的Python实现-异常和语法错误

全网最适合入门的面向对象编程教程：23 类和对象的Python实现-抛出异常

全网最适合入门的面向对象编程教程：24 类和对象的Python实现-异常的捕获与处理

全网最适合入门的面向对象编程教程：25 类和对象的Python实现-Python判断输入数据类型

全网最适合入门的面向对象编程教程：26 类和对象的Python实现-上下文管理器和with语句

全网最适合入门的面向对象编程教程：27 类和对象的Python实现-Python中异常层级与自定义异常类的实现

全网最适合入门的面向对象编程教程：28 类和对象的Python实现-Python编程原则、哲学和规范大汇总

全网最适合入门的面向对象编程教程：29 类和对象的Python实现-断言与防御性编程和help函数的使用

全网最适合入门的面向对象编程教程：30 Python的内置数据类型-object根类

全网最适合入门的面向对象编程教程：31 Python的内置数据类型-对象Object和类型Type

全网最适合入门的面向对象编程教程：32 Python的内置数据类型-类Class和实例Instance

全网最适合入门的面向对象编程教程：33 Python的内置数据类型-对象Object和类型Type的关系

全网最适合入门的面向对象编程教程：34 Python的内置数据类型-Python常用复合数据类型：元组和命名元组

全网最适合入门的面向对象编程教程：35 Python的内置数据类型-文档字符串和__doc__属性

全网最适合入门的面向对象编程教程：36 Python的内置数据类型-字典

全网最适合入门的面向对象编程教程：37 Python常用复合数据类型-列表和列表推导式

全网最适合入门的面向对象编程教程：38 Python常用复合数据类型-使用列表实现堆栈、队列和双端队列

全网最适合入门的面向对象编程教程：39 Python常用复合数据类型-集合

全网最适合入门的面向对象编程教程：40 Python常用复合数据类型-枚举和enum模块的使用

全网最适合入门的面向对象编程教程：41 Python常用复合数据类型-队列（FIFO、LIFO、优先级队列、双端队列和环形队列）

全网最适合入门的面向对象编程教程：42 Python常用复合数据类型-collections容器数据类型

全网最适合入门的面向对象编程教程：43 Python常用复合数据类型-扩展内置数据类型

全网最适合入门的面向对象编程教程：44 Python内置函数与魔法方法-重写内置类型的魔法方法

全网最适合入门的面向对象编程教程：45 Python实现常见数据结构-链表、树、哈希表、图和堆

全网最适合入门的面向对象编程教程：46 Python函数方法与接口-函数与事件驱动框架

全网最适合入门的面向对象编程教程：47 Python函数方法与接口-回调函数Callback

全网最适合入门的面向对象编程教程：48 Python函数方法与接口-位置参数、默认参数、可变参数和关键字参数

全网最适合入门的面向对象编程教程：49 Python函数方法与接口-函数与方法的区别和lamda匿名函数

全网最适合入门的面向对象编程教程：50 Python函数方法与接口-接口和抽象基类

全网最适合入门的面向对象编程教程：51 Python函数方法与接口-使用Zope实现接口

全网最适合入门的面向对象编程教程：52 Python函数方法与接口-Protocol协议与接口

全网最适合入门的面向对象编程教程：53 Python字符串与序列化-字符串与字符编码

全网最适合入门的面向对象编程教程：54 Python字符串与序列化-字符串格式化与format方法

全网最适合入门的面向对象编程教程：55 Python字符串与序列化-字节序列类型和可变字节字符串

全网最适合入门的面向对象编程教程：56 Python字符串与序列化-正则表达式和re模块应用

全网最适合入门的面向对象编程教程：57 Python字符串与序列化-序列化与反序列化

全网最适合入门的面向对象编程教程：58 Python字符串与序列化-序列化Web对象的定义与实现

全网最适合入门的面向对象编程教程：59 Python并行与并发-并行与并发和线程与进程

一文速通Python并行计算：00 并行计算的基本概念

一文速通Python并行计算：01 Python多线程编程-基本概念、切换流程、GIL锁机制和生产者与消费者模型

一文速通Python并行计算：02 Python多线程编程-threading模块、线程的创建和查询与守护线程

一文速通Python并行计算：03 Python多线程编程-多线程同步（上）—基于互斥锁、递归锁和信号量

一文速通Python并行计算：04 Python多线程编程-多线程同步（下）—基于条件变量、事件和屏障

一文速通Python并行计算：05 Python多线程编程-线程的定时运行

一文速通Python并行计算：06 Python多线程编程-基于队列进行通信

一文速通Python并行计算：07 Python多线程编程-线程池的使用和多线程的性能评估

一文速通Python并行计算：08 Python多进程编程-进程的创建命名、获取ID、守护进程的创建和终止进程

一文速通Python并行计算：09 Python多进程编程-进程之间的数据同步-基于互斥锁、递归锁、信号量、条件变量、事件和屏障

文档获取：

可访问如下链接进行对文档下载：

https://github.com/leezisheng/Doc

该文档是一份关于 并行计算 和 Python 并发编程 的学习指南，内容涵盖了并行计算的基本概念、Python 多线程编程、多进程编程以及协程编程的核心知识点：

正文

1. 共享内存

共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。

其特点包括：

共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝。
为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间。进程就可以直接读写这一块内存而不需要进行数据的拷贝，从而大大提高效率。（文件映射）
由于多个进程共享一段内存，因此也需要依靠某种同步机制。

虽然共享内存可以实现快速在进程间传递数据，但也存在内存中的内容会被其他进程覆盖或者篡改的缺点，需要用进程间同步方式保证数据安全。

multiprocessing 中提供了 Value 和 Array，可以将数据存储在共享内存映射中，供全部进程访问。

1.1 共享内存-数值型

首先我们来看，value 的数据格式：

Value(typecode_or_type, *args, lock=True)

功能：

得到一个共享内存对象，并且存入初始值，method of multiprocessing
返回 Returns a synchronized shared object（同步共享对象）
typecode_or_type：定义了返回类型（转换成 C 语言中存储类型），它要么是一个 ctypes 类型，要么是一个代表 ctypes 类型的 code。ctypes 是 python 的一个外部函数库，它提供了和 C 语言兼容的数据类型，可以调用 DLLs 或共享库的函数，能被用作在 python 中包裹这些库。
*args：开辟一个空间，并赋一个 args 值，值得类型不限
lock 默认自动上锁(同步锁)

示例代码如下，可以看到子进程改变数值的值，主进程跟着改变：

import multiprocessing

def func(num):

    num.value = 11

if __name__ == "__main__":

    # i表示整型,主进程与子进程共享这个value。

    num = multiprocessing.Value("i", 10)

    print(num.value)

    p = multiprocessing.Process(target=func, args=(num,))

    p.start()

    p.join()

    print(num.value)

1.2 共享内存-数组型

Array 的数据格式：

Array(typecode_or_type, size_or_initializer, *, lock=True)

功能：

使用基本类似于 Value，Returns a synchronized shared array （是一个可迭代对象）
typecode_or_type：定义转换成 C 语言的存储类型；
size_or_initializer：初始化共享内存空间，如果是一个整数，那就会当做数组的长度，并且整个数组的内存会初始化为 0。否则，会被当成一个序列用于初始化数组中的每一个元素。
lock 默认自动上锁(同步锁)

Value、Array 数据存储类型参数如下（部分）：

示例代码如下，可以看到子进程改变数列元素，主进程跟着改变：

import multiprocessing

def func(num):

    num[2] = 9999  # 子进程改变数组，主进程跟着改变

if __name__ == "__main__":

    num = multiprocessing.Array("i", [1, 2, 3, 4, 5])  # 主进程与子进程共享这个数组

    print(num[:])

    p = multiprocessing.Process(target=func, args=(num,))

    p.start()

    p.join()

    print(num[:])

1.3 自定义数据结构

这里利用 ctypes 中类来定义结构体，用于定义结构体的类需要继承自 ctypes 的 Structure 基类，而后通过定义类的 _fields_ 属性来定义结构体的构成。_fields_ 属性一般定义为一个二维的 tuple，而对于其中的每一个一维 tuple，其需要定义两个值，第一个值为一个字符串，用作结构体内部的变量名，第二个值为一个 ctypes 类型，用于定义当前结构体变量所定义的数据类型。注意，在 Python 中定义的结构体，其变量名,类名等均可以不同于 C 语言中的变量名，但结构体变量的数量、数据类型与顺序必须严格对应于 C 源码中的定义，否则可能将导致内存访问出错。

代码如下：

**from multiprocessing import Process, Lock**

from multiprocessing.sharedctypes import Value, Array

from ctypes import Structure, c_double

_# 自定义数据结构_

class Point(Structure):

    _# 定义了一个结构体类型，其等同于C中的struct声明。_

    _# 此结构体定义了两个结构体变量：x对应于一个int类型，y对应于一个double类型。_

    _fields_ = [('x', c_double), ('y', c_double)]

def modify(n, x, s, A):

    n.value **= 2

    x.value **= 2

    s.value = s.value.upper()

    for a in A:

        a.x **= 2

        a.y **= 2

if __name__ == '__main__':

    lock = Lock()

    n = Value('i', 7)  _# 定义int型_

    x = Value(c_double, 1.0/3.0, lock=False)  _# 定义ctypes类型_

    s = Array('c', b'hello world', lock=lock)  _# 定义字符串_

    A = Array(Point, [(1.875, -6.25), (-5.75, 2.0), (2.375, 9.5)], lock=lock)

_# 定义Point类型的数组_

    p = Process(target=modify, args=(n, x, s, A))

    p.start()

    p.join()

    print(n.value)

    print(x.value)

    print(s.value)

    print([(a.x, a.y) for a in A])

2.数据管理器

除了共享内存的方式，另一种进程间共享对象的方式是使用服务进程：

由 Manager() 返回的管理器对象控制一个服务进程，该进程保存 Python 对象并允许其他进程使用代理操作它们，（注意，Manager 需要手动上锁）。

管理者有以下特性：

它控制着管理共享对象的服务进程；
它确保当某一进程修改了共享对象之后，所有的进程拿到额共享对象都得到了更新。

Manager() 返回的管理器支持的类型有：

list、 dict、 Namespace 、 Lock、 RLock、Semaphore、 BoundedSemaphore、 Condition 、Event、 Barrier、 Queue、 Value 和 Array。

示例代码如下，主进程定义了一个字典和一个列表，在子进程中，可以添加和修改字典的内容，在列表中插入新的数据，实现进程间的数据共享，即可以共同修改同一份数据。

from multiprocessing import Process, Manager

def fun1(dic,lis,index):

    dic[index] = 'a'

    dic['2'] = 'b'

    lis.append(index)

if __name__ == '__main__':

    with Manager() as manager:

        _# 注意字典的声明方式，不能直接通过{}来定义_

        dic = manager.dict()

        _# [0,1,2,3,4]_

        l = manager.list(range(5))

        process_list = []

        for i in range(10):

            p = Process(target=fun1, args=(dic,l,i))

            p.start()

            process_list.append(p)

        for res in process_list:

            res.join()

        print(dic)

        print(l)