python 多处理变量

Question

如何在同一项目的另一个进程中使用从一个进程获得的数据(变量)？例如，在下面的代码中，我想在界面中使用变量“b”来绘制和分析它。谢谢!

import time
import multiprocessing
import time
import os
import sys
import matplotlib.animation as animation
import time
import libtiepie
import numpy as np
import matplotlib.pyplot as plt
from copy import deepcopy
from printinfo import *
from math import*
import pylab
import tkinter as tk
import matplotlib.animation as animation
from tkinter import*
from tkinter import ttk
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
from matplotlib.figure import Figure
from matplotlib.animation import FuncAnimation

def calc_square():

    k=0
    fig=plt.figure()
    while k<3000:

        # Print library info:
        print_library_info()

        # Search for devices:
        libtiepie.device_list.update()

        # Try to open an oscilloscope with block measurement support:
        scp = None
        for item in libtiepie.device_list:
            if item.can_open(libtiepie.DEVICETYPE_OSCILLOSCOPE):
                scp = item.open_oscilloscope()
                if scp.measure_modes & libtiepie.MM_BLOCK:
                    break
                else:
                    scp = None

        if scp:
            try:

                    # Set measure mode:
                    scp.measure_mode = libtiepie.MM_BLOCK

                    # Set sample frequency:
                    scp.sample_frequency = 5e6  # 1 MHz

                    # Set record length:
                    scp.record_length = 1000  # 15000 samples

                    # Set pre sample ratio:
                    scp.pre_sample_ratio = 0.1  # 0 %

                    # For all channels:
                    for ch in scp.channels:
                        # Enable channel to measure it:
                        ch.enabled = True

                        # Set range:
                        ch.range = 8  # 8 V

                        # Set coupling:
                        ch.coupling = libtiepie.CK_ACV  # DC Volt

                    # Set trigger timeout:
                    scp.trigger_time_out = 100e-3  # 100 ms

                    # Disable all channel trigger sources:
                    for ch in scp.channels:
                        ch.trigger.enabled = False

                    # Setup channel trigger:
                    ch = scp.channels[0]  # Ch 1

                    # Enable trigger source:
                    ch.trigger.enabled = True

                    # Kind:
                    ch.trigger.kind = libtiepie.TK_RISINGEDGE  # Rising edge

                    # Level:
                    ch.trigger.levels[0] = 0.75  # 50 %

                    # Hysteresis:
                    ch.trigger.hystereses[0] = 0.1  # 5 %

                    # Print oscilloscope info:
                    #print_device_info(scp)

                    # Start measurement:
                    scp.start()

                    # Wait for measurement to complete:
                    while not scp.is_data_ready:
                        time.sleep(0.01)  # 10 ms delay, to save CPU time

                    # Get data:
                    data = scp.get_data()

                    ax = fig.add_subplot(111)
                    t = np.linspace(0, (scp.record_length/scp.sample_frequency)*1000, scp.record_length)
                    a=deepcopy(data)
                    a=np.transpose(a)
                    b=a[:,0]
                    #ax.plot(t,b)
                    #plt.ion()
                    #plt.show()
                    #plt.pause(0.001)
                    #ax.cla()

            except Exception as e:
                print('Exception: ' + e.message)
                sys.exit(1)

            # Close oscilloscope:
            del scp

        else:
            print('No oscilloscope available with block measurement support!')
        k=k+1

if __name__ == "__main__":

    p1 = multiprocessing.Process(target=calc_square)      

    p1.start()
    # p2.start()
    p1.join()
    # p2.join()

Answer 1

要将数据从一个进程发送到另一个进程，您可以使用多处理队列，如 docs 中所述。

from multiprocessing import Process, Queue
q = Queue()

def function1(q):
  a = 3434
  q.put(a)
def function2(a):
  c = a**2
  q.put(c)
p1 = Process(target=function1, args=(q,))
p1.start()
b = q.get()
p1.join()
p2 = Process(target=function2, args=(b,))
p2.start()
c = q.get()
p2.join()
print c

这是工作 example以及将一个进程的变量传递给另一个进程