我是 Python 编码的菜鸟，我正在尝试学习多处理以解决我遇到的问题。

我有一个带有树莓派 (linux) 的项目，我试图通过 TCP 连接在另一台 PC/设备 (windows) 上共享数据。我制作了可用的服务器/客户端代码(树莓派上的服务器和 PC 上的客户端)。

下一步是创建一个可视化应用程序(在本例中我选择 kivy)并通过该应用程序直接连接我的 PC 并将数据发送到我的树莓派，PC 是这里的客户端，直接来自 python/kivy 代码。

问题是，当我在我的 kivy 应用程序中引入 IP 和 PORT 时，脚本正在连接我，但立即终止服务器，我希望我的服务器一直保持事件状态。

其他问题，假设服务器没有被代码杀死，在另一个名为 send_data 的函数中我想将速度和角度变量发送到我的服务器并且仍然连接到服务器并且服务器还活着，所以我唯一的选项是多处理。

树莓派服务器代码:

import socket

host = ''
port = int(input("Port: "))

speed = []
angle = []

def setupServer():
   s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
   print ("Socket created")
   try:
      s.bind((host, port))
   except socket.error as msg:
      print(msg)
   print("Socket bind complete.")
   return s

def setupConnection():
   s.listen(1)
   conn, address = s.accept()
   print("Connected to: " +address[0] + ":" + str(address[1]))
   return conn

def dataTransfer(conn):
   global speed,angle

   data = conn.recv(1024)
   data = data.decode('utf-8')
   """ split the data """
   dataMessage = data.split(' ',1)
   speed = dataMessage[0]
   angle = dataMessage[1]

   print(speed)
   print(angle)

   if dataMessage[0] == 'exit':
       print("Client has left the server")
       break
   if dataMessage[0] == 'kill':
       print("Server is shutting down")
       s.close()
       break

   conn.close()


s = setupServer()

while True:
   try:
      conn = setupConnection()
      dataTransfer(conn)
   except:
      break

使用 kivy 模块为我的客户编写的代码:

import kivy
import socket
import multiprocessing

kivy.require('1.10.1')

from kivy.app import App
from kivy.uix.button import Label
from kivy.uix.gridlayout import GridLayout
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
from kivy.config import Config
from kivy.uix.widget import Widget
from kivy.properties import ObjectProperty


Config.set('graphics', 'width', '400')
Config.set('graphics', 'height', '400')


class MyGrid(Widget):
    ip = ObjectProperty(None)
    port = ObjectProperty(None)
    speed = ObjectProperty(None)
    angle = ObjectProperty(None)

    def connecting(self):
        h = self.ip.text
        p = int(self.port.text)

        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((h, p))
        self.lbl.text = "Connected to server!"

        return s

    def __init__(self):
        super(MyGrid, self).__init__()

    def send_data(self):
        h = self.ip.text
        p = int(self.port.text)
        speed = self.speed.text
        angle = self.angle.text

        s = MyGrid.connecting(h, p)

        var = speed + " " + angle
        s.send(str.encode(str(var)))

        #reply = s.recv(1024)
        #print(reply.decode('utf-8'))
        self.lbl.text = "Speed and angle has been send!"

        s.close()

    def dct(self):
        h = self.ip.text
        p = int(self.port.text)

        s = MyGrid.connecting(h, p)
        s.close()
        self.lbl.text = "Client disconnected!"

    def stop_srvv(self):
        h = self.ip.text
        p = int(self.port.text)

        s = MyGrid.connecting(h, p)

        s.send(str.encode(str("kill ")))

        reply = s.recv(1024)
        print(reply.decode('utf-8'))
        self.lbl.text = "Server stopped!"


class MyApp(App):
    def build(self):
        return MyGrid()


if __name__ == "__main__":
    MyApp().run()

kivy 样式部分代码:

<MyGrid>
    lbl: my_label
    ip: ip
    port: port
    speed: speed
    angle: angle

    GridLayout:
        cols: 1
        size: root.width, root.height

        GridLayout:
            cols: 2
            Label:
                text: "IP"

            TextInput:
                id: ip
                multiline: False

            Label:
                text: "PORT"

            TextInput:
                id: port
                multiline: False

            Label:
                text: "Speed"

            TextInput:
                id: speed
                multiline: False

            Label:
                text: "Angle"

            TextInput:
                id: angle
                multiline: False

        GridLayout:
            cols: 2
            Button:
                text: "CONNECT"
                on_press: root.connecting()

            Button:
                text: "DISCONNECT"
                on_press: root.dct()

        GridLayout:
            cols: 2

            Button:
                text: "SEND DATA"
                on_press: root.send_data()

            Button:
                text: "STOP SERVER"
                on_press: root.stop_srvv()

            Label:
                id: my_label
                text: ""

我想通过 TCP 连接连接、断开连接和发送数据，所有这些都与服务器一直处于事件状态(服务器应该仅在我按下“停止服务器”按钮时关闭)。 显然 kivy 模块有一个奇怪的结构，我真的不明白如何在我的问题和 kivy 结构中分配多处理。

你们中有人可以看看我的代码并使用多处理更正它来完成我需要的事情，或者至少给我一个建议/教程之类的吗？

更新:如您所见，我还没有使用任何多处理代码，首先我尝试使用 pool 和 map 将连接部分划分为一个核心，其余部分在另一个核心上，但要保持我的服务器还活着，我需要在连接区有一个循环序列。 (我的笔记本只有2核)

最佳答案

使用threading反而。 multiprocessing 基本上就像启动一个完整的其他进程，除非您写入文件，否则共享数据并不容易。使用线程，您处于同一个进程中，并且可以在线程之间访问变量。
下面是一个如何实现线程的小例子。

from kivy.app import App
from kivy.lang import Builder
from kivy.properties import StringProperty
import threading

sock = socket.socket()
sock.connect((host, port))


KV = """

BoxLayout:
    Label:
        text: app.label_text

"""

class MyApp(App):
    label_text = StringProperty("")

    def build(self):
        threading.Thread(target=self.update_label).start()
        return Builder.load_string(KV)


    def update_label(self):
        while True:
            self.label_text = sock.recv(1025)


MyApp().run()

关于python - 使用 TCP 同时在两个进程之间进行多处理连接，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55340744/