Python EOFError:类内的输入用完

我有以下代码，需要一次读取多个传感器。我已经设置了线程和多处理来为我完成这项任务。当线程和多线程处理代码在主类之外时，它可以正常工作，但类不能使用它检索的数据。当我将多线程代码放入类中时，我遇到了一个

eoferor:runoutofinput

错误

代码如下：

import os
import multiprocessing
from multiprocessing import Process, Pool
import threading
import queue
import tkinter as tk
from tkinter import *
from tkinter import ttk
import time
import minimalmodbus
import serial
minimalmodbus.CLOSE_PORT_AFTER_EACH_CALL = True
THREAD_LOCK = threading.Lock()

class Application(tk.Frame):
    def __init__(self, master=None):
        super().__init__(master)

        self.pack()

        self.first_gas_labelframe = LabelFrame(self, text="Gas 1", width=100)
        self.first_gas_labelframe.grid(row=0, column=0)

        self.value_label = Label(self.first_gas_labelframe, text="Value")
        self.value_label.grid(row=0, column=0)

        self.unit_label = Label(self.first_gas_labelframe, text="Unit")
        self.unit_label.grid(row=1, column=0)

        self.temp_label = Label(self.first_gas_labelframe, text="Temp")
        self.temp_label.grid(row=2, column=0)

        self.temp_label6 = Label(self.first_gas_labelframe6, text="Temp")
        self.temp_label6.grid(row=2, column=0)

        self.timer_button = tk.Button(self, text='Start', command=self.start_run)
        self.timer_button.grid(row=2, column=0)


    def start_run(self):
        self.all_thread()

    def all_thread(self):
        thread = threading.Thread(target=self.all_process)
        thread.start()

    def all_process(self):
        all_ports = port_num()
        gas = minimalmodbus.Instrument("COM3", 1)
        gas.serial.baudrate = 9600
        gas.serial.bytesize = 8
        gas.serial.parity = serial.PARITY_NONE
        gas.serial.stopbits = 1
        gas.serial.timeout = 0.25
        gas.mode = minimalmodbus.MODE_RTU

        gas_list = [gas]
        processes = []
        while len(gas_list) > 0:
            val = 1
            with THREAD_LOCK:
                for sen in gas_list:
                    proc = Process(target=self.main_reader, args=(sen, val))
                    processes.append(proc)
                    proc.start()
                    val += 1
                for sen in processes:
                    sen.join()
                time.sleep(1)

    def main_reader(sen, val):
        try:
            read = sen.read_registers(0,42)
        except OSError:
            read = "Communication Error"
        except ValueError:
            read = "RTU Error"
        print(read)

if __name__ == '__main__':
    root = tk.Tk()
    root.geometry("1000x600")
    app = Application()
    app.mainloop()

---

通过一些调试，问题发生在

proc.start（）

处，但

proc

中有数据。列表中也有数据，这就是为什么我不明白为什么它没有输入。注意：在我的代码中，

gas\u列表中有六个条目

您不能像这样使用多重处理（当然，您可以，但结果将是不可预测的）-当您创建一个新进程时，列表中的

最小Modbus。仪表

对象不会作为参考传递，而是作为一个全新的对象传递。只要您

start（）

a

multi-Process.Process

实例，Python基本上都会运行一个全新的Python解释器实例，而且由于不同的进程具有不同的堆栈，它们无法共享内部内存，因此Python实际上会对传递的参数进行pickle，将它们发送到进程，然后在那里取消勾选，从而产生两个进程（父进程和子进程）具有相同数据的错觉

如果调用

self.main_reader（pickle.load（pickle.dumps（sen）），val）而不是创建一个新的
multiprocessing.Process
，您可以自己观察它（
val
也会被pickle，但作为一个泛型，它在这里并不重要）

同样的过程也发生在
应用程序.main_reader（）
方法上（尽管定义很奇怪），您设置它的方式是，您的整个
应用程序
实例实际上在子过程中被重新创建，以便Python可以调用其
main_reader（）
方法

相反，您可以将所需的参数传递给子进程函数，以便重新创建原始对象，然后在函数启动时创建对象。例如，如果将
应用程序.all\u process（）
方法修改为：

def all_process(self):
    gas = {"__init__": ("COM3", 1)
           "serial": {
               "baudrate": 9600,
               "bytesize": 8,
               "parity": serial.PARITY_NONE,
               "stopbits": 1,
               "timeout": 0.25
           },
           "mode": minimalmodbus.MODE_RTU}

    gas_list = [gas]
    processes = []
    while len(gas_list) > 0:
        val = 1
        for sen in gas_list:
            # we'll be calling the main_reader function outside of the Application instead
            proc = multiprocessing.Process(target=main_reader, args=(sen, val))
            processes.append(proc)
            proc.start()
            val += 1
        for sen in processes:
            sen.join()
        time.sleep(1)
        # you do plan to exit this loop, right?

然后让您的
main_reader（）
函数在
应用程序
类之外定义为：

def main_reader(data, val):  # notice it's outside of the Application scope
    sen = minimalmodbus.Instrument(*data["__init__"])  # initialize Instrument
    for k, v in data["serial"].items():  # apply the serial settings
        setattr(sen.serial, k, v)
    sen.mode = data["mode"]  # set the mode
    try:
        read = sen.read_registers(0, 42)
    except OSError:
        read = "Communication Error"
    except ValueError:
        read = "RTU Error"
    print(read)

它应该停止抛出错误。另外，您还使用了
线程。在原始代码中锁定
——我不知道您试图用它实现什么，但它肯定不会做您认为它能做的事。
回答得很好！看来我还有很多东西要学。我是否可以在
应用程序
类中保留
主读卡器
，这样如果我需要更改Tkinter中的标签，我就可以在同一个类中引用所有标签？@Evan-有一种方法-有些方法。检查，但它仍然创建一个新实例，只是以一种更可控的方式。如果您只需要“共享”标签（字符串），那么最好在全局命名空间中创建一个单独的结构/类来保存标签，然后从
应用程序
类和独立函数中引用它们。只需确保您没有在
\uuuu name\uuuu==“\uuuuu main\uuuuu”
保护下定义它。我需要在流程结束后更改每个标签，这将是每秒钟一次。我只需要一种方法将
读取
到
Application（）
@Evan中-在这种情况下，使用一个支持多处理的结构来交换数据。您可以使用作为进程之间的队列（如中），也可以创建并使用其多处理感知列表和字典在主进程和子进程之间交换数据。