python共享内存

https://docs.python.org/zh-cn/3/library/multiprocessing.html

共享内存

可以使用 Value 或 Array 将数据存储在共享内存映射中。例如，以下代码:

from multiprocessing import Process, Value, Array

def f(n, a):
    n.value = 3.1415927
    for i in range(len(a)):
        a[i] = -a[i]

if __name__ == '__main__':
    num = Value('d', 0.0)
    arr = Array('i', range(10))

    p = Process(target=f, args=(num, arr))
     p.deamon=True  #伴随主进程关闭而关闭
    p.start()
  

    print(num.value)
    print(arr[:])

 不同种类数据共享

https://blog.csdn.net/lechunluo3/article/details/79005910

Manager管理的共享数据类型有：Value、Array、dict、list、Lock、Semaphore等等，同时Manager还可以共享类的实例对象。
实例代码：

from multiprocessing import Process,Manager
def func1(shareList,shareValue,shareDict,lock):
    with lock:
        shareValue.value+=1
        shareDict[1]='1'
        shareDict[2]='2'
        for i in xrange(len(shareList)):
            shareList[i]+=1

if __name__ == '__main__':
    manager=Manager()
    list1=manager.list([1,2,3,4,5])
    dict1=manager.dict()#存str类型数据
    array1=manager.Array('i',range(10))
    value1=manager.Value('i',1)
    lock=manager.Lock()
    proc=[Process(target=func1,args=(list1,value1,dict1,lock)) for i in xrange(20)]
    for p in proc:
        p.start()
    for p in proc:
        p.join()
    print list1
    print dict1
    print array1
    print value1

　　结果

[21, 22, 23, 24, 25]
{1: '1', 2: '2'}
array('i', [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Value('i', 21)

　关于str类型数组共享内存的使用

from multiprocessing import Process,Manager

#1初始化共享内存
manager=Manager()
str_msg=manager.dict()#存str类型数据
str_msg[1]='0'        #用几个必须预先初始化 否则后面无法访问
str_msg[2]='0'        #用几个必须预先初始化 否则后面无法访问

#2线程锁 保护多个线成对数据控制
lock=manager.Lock()

#3要执行的函数
def func1(shareDict,lock):
    with lock:      
        shareDict[1]=str(2+int(shareDict[1]))
        shareDict[2]=str(3+int(shareDict[2]))
  
 
#4开启次线程  使用的函数+输入共享数据（str）+线程锁
proc=Process(target=func1,args=(str_msg,lock))
proc.deamon=True  #伴随主进程关闭
proc.start()      #开始
proc.join()       #加入线程池

#5主线程开启
while 1:       
    print(str_msg[1])
    print(str_msg[2])
   

　　

　

读两个串口，数据给共享内存

普通的读取

# -*- coding: utf-8 -*
import serial
import time
from multiprocessing import Process, Value, Array

#读取温度和湿度
def serial_th(num,arr):
    ser = serial.Serial('/dev/ttyUSB1', 115200)

    if ser.isOpen == False:
        ser.open()                # 打开串口
    #ser.write(b"Raspberry pi is ready")
    try:
        while True:
            line = str(ser.readline())
            fengefu='-'
            a=line.strip().split(fengefu)    # x.strip()#除去每行的换行符 按照：分割
    
            tv = "".join(a[1:2] ).strip()  # 去除空格
            hv = "".join(a[3:4]).strip()  # 去除空格
            arr[0]=int(tv)
            arr[1]=int(hv)
            #print('t-'+str(arr[0])+"-h-"+str(arr[1]))
          
            #time.sleep(0.1)                  # 软件延时
    except KeyboardInterrupt:
        ser.close()


#读取温度和湿度
def serial_lmq29(num,arr):
    ser = serial.Serial('/dev/ttyUSB0', 115200)

    if ser.isOpen == False:
        ser.open()                # 打开串口
    #ser.write(b"Raspberry pi is ready")
    try:
        while True:
            line = str(ser.readline())
            fengefu='-'
            a=line.strip().split(fengefu)    # x.strip()#除去每行的换行符 按照：分割
    
            mq2 = "".join(a[1:2] ).strip()  # 去除空格
            light = "".join(a[3:4]).strip()  # 去除空格
            mq9 = "".join(a[5:6]).strip()  # 去除空格
            #print(mq9)
         
            arr[2]=int(mq2)
            arr[3]=int(light)
            arr[4]=int(mq9)
            #print('mq2-'+ str(arr[2]) +'-lihgt-'+str(arr[3])+'-mq9-'+str(arr[4]))
         
            #time.sleep(0.1)                  # 软件延时
    except KeyboardInterrupt:
        ser.close()        
        
        
num_share = Value('d', 0.0)
arr_share = Array('i', range(5))


p_wh = Process(target=serial_th, args=(num_share,arr_share))
p_wh.deamon=True  #伴随主进程关闭而关闭
p_wh.start()


p_l29 = Process(target=serial_lmq29, args=(num_share,arr_share))
p_l29.deamon=True
p_l29.start()

while 1:
    # 打印共享内存数据
     print(arr_share[:])

　　

类的读取、

# -*- coding: utf-8 -*
import serial
import time
from multiprocessing import Process, Value, Array


class Class_sensor:
    def __init__(self):
        pass    
    
    #读取温度和湿度
    def serial_th(self,num,arr):
        ser = serial.Serial('/dev/ttyUSB1', 115200)

        if ser.isOpen == False:
            ser.open()                # 打开串口
        #ser.write(b"Raspberry pi is ready")
        try:
            while True:
                line = str(ser.readline())
                fengefu='-'
                a=line.strip().split(fengefu)    # x.strip()#除去每行的换行符 按照：分割
        
                tv = "".join(a[1:2] ).strip()  # 去除空格
                hv = "".join(a[3:4]).strip()  # 去除空格
                arr[0]=int(tv)
                arr[1]=int(hv)
                #print('t-'+str(arr[0])+"-h-"+str(arr[1]))
              
                #time.sleep(0.1)                  # 软件延时
        except KeyboardInterrupt:
            ser.close()


    #读取温度和湿度
    def serial_lmq29(self,num,arr):
        ser = serial.Serial('/dev/ttyUSB0', 115200)

        if ser.isOpen == False:
            ser.open()                # 打开串口
        #ser.write(b"Raspberry pi is ready")
        try:
            while True:
                line = str(ser.readline())
                fengefu='-'
                a=line.strip().split(fengefu)    # x.strip()#除去每行的换行符 按照：分割
        
                mq2 = "".join(a[1:2] ).strip()  # 去除空格
                light = "".join(a[3:4]).strip()  # 去除空格
                mq9 = "".join(a[5:6]).strip()  # 去除空格
                #print(mq9)
             
                arr[2]=int(mq2)
                arr[3]=int(light)
                arr[4]=int(mq9)
                #print('mq2-'+ str(arr[2]) +'-lihgt-'+str(arr[3])+'-mq9-'+str(arr[4]))
             
                #time.sleep(0.1)                  # 软件延时
        except KeyboardInterrupt:
            ser.close()        
            
    def class_int(self):        

        self.num_share = Value('d', 0.0)
        self.arr_share = Array('i', range(5))

        p_wh = Process(target=self.serial_th, args=(self.num_share,self.arr_share))
        p_wh.deamon=True  #伴随主进程关闭而关闭
        p_wh.start()


        p_l29 = Process(target=self.serial_lmq29, args=(self.num_share,self.arr_share))
        p_l29.deamon=True
        p_l29.start()

t = Class_sensor()#类的初始化
t.class_int()#串口初始化
while 1:
    # 打印共享内存数据
     print(t.arr_share[:])

　　

字符类型的共享内存串口解析获取

'''
函数作用：
1开启其一个进程
2开启一个串口
3串口数据解析
4开辟共享内存 str 接收温度 湿度 mq2数据 （字符类型）
5主进程创建类调用这些数据

'''

# -*- coding: utf-8 -*
import serial
import time
from multiprocessing import Process,Manager
 
 
class Class_sensor:
    def __init__(self):
        pass   
       
    #读取温度和湿度和MQ2烟雾火焰
    def serial_wsmq2(self,arr,clock):
        ser = serial.Serial('/dev/ttyUSB0', 9600)
 
        if ser.isOpen == False:
            ser.open()                # 打开串口
        #ser.write(b"Raspberry pi is ready")
        try:
            while True:
                line = str(ser.readline())
                fengefu='-'
                a=line.strip().split(fengefu)    # x.strip()#除去每行的换行符 按照：分割
         
                wendu = "".join(a[1:2] ).strip()  # 去除空格
                shidu = "".join(a[3:4]).strip()  # 去除空格
                mq2 = "".join(a[5:6]).strip()  # 去除空格
                #print(mq9)
                
                with clock:
                    arr[1]=str(wendu)
                    arr[2]=str(shidu)
                    arr[3]=str(mq2)
                print('温度-'+ str(arr[1]) +'-湿度-'+str(arr[2])+'-火焰烟雾-'+str(arr[3]))
              
                #time.sleep(0.1)                  # 软件延时
        except KeyboardInterrupt:
            ser.close()       
             
    def class_int(self):       
 
        #1初始化共享内存
        self.manager=Manager()
        self.str_msg=self.manager.dict()#存str类型数据
        self.str_msg[1]='0'        #用几个必须预先初始化 否则后面无法访问
        self.str_msg[2]='0'        #用几个必须预先初始化 否则后面无法访问
        self.str_msg[3]='0'  
        #2线程锁 保护多个线成对数据控制
        self.lock=self.manager.Lock()
 
        p = Process(target=self.serial_wsmq2, args=(self.str_msg,self.lock))
        p.deamon=True  #伴随主进程关闭而关闭
        p.start()

#共享内存测试
t = Class_sensor()#类的初始化
t.class_int()#串口初始化
print(t.str_msg[1]) #调用数据
print(t.str_msg[2]) #调用数据
print(t.str_msg[3]) #调用数据