如何让高频线程与低频更新的类对话？

Question

概括

我正在做一个需要低 delta_t 的实时物理模拟。我已将此模拟连接到 python-arcade 游戏窗口以实时显示信息。

我为物理线程制作了一个单独的线程，因为物理线程中有一些昂贵的矩阵乘法。然后，当更新完成时，我设置游戏窗口类的结果状态，游戏窗口在绘制新框架时可以显示这些状态。

因此，我的想法是游戏窗口类只需要担心在屏幕上的绘制，而物理线程负责所有的计算。

但是，游戏窗口和线程之间的通信存在瓶颈，我不知道是否有深入的了解。

我想做的最小表示：

import threading

import time

import math

import arcade

class DisplayWindow(arcade.Window):

    def __init__(self):

        super().__init__(width=400, height=400)

        self.state = 0

        self.FPS = 0

    def set_state(self, state):

        self.state = state

    def on_update(self, delta_time: float):

        self.FPS = 1. / delta_time

    def on_draw(self):

        arcade.start_render()

        arcade.draw_text(f'FPS: {self.FPS:0.2f}', 20, 20, arcade.color.WHITE)

        arcade.draw_rectangle_filled(center_x=self.state * self.width,

                                     center_y=self.height/2,

                                     color=arcade.color.WHITE,

                                     tilt_angle=0,

                                     width=10,

                                     height=10)

# Thread to simulate physics.

def simulation(display):

    t_0 = time.time()

    while True:

        # Expensive calculation that needs high frequency:

        t = time.time() - t_0

        x = math.sin(t) / 2 + 0.5       # sinusoid for demonstration

        # Send it to the display window

        display.set_state(state=x)

        # time.sleep(0.1)               # runs smoother with this

def main():

    display_window = DisplayWindow()

    physics_thread = threading.Thread(target=simulation, args=(display_window,), daemon=True)

    physics_thread.start()

    arcade.run()

    return 0

if __name__ == '__main__':

    main()

预期结果：高帧率的平滑模拟。街机窗口只需以 30 或 60 fps 运行 on_draw。它只需要画一些东西。

实际结果：物理循环运行速度超快并调用 FPS drop。

当我在物理线程中添加 time.sleep(0.1) 时，整个事情变得更加顺畅，我猜出于某种原因set_state( _ )会减慢绘制循环。

Answer 1

Python 线程可能不是您尝试做的工作的理想工具。尽管将 Python 线程视为并发运行可能很诱人，但事实并非如此：全局解释器锁 (GIL) 只允许一个线程控制 Python 解释器。更多信息正因为如此，该arcade.Window对象无法及早控制 Python 解释器并运行其所有更新函数，因为 GIL 始终“专注”simulation于physics_thread.GIL 只会在physics_thread运行一定数量的指令或使用which 在线程上执行physics_thread设置为睡眠后才释放对 的关注并在其他线程上寻找其他事情要做。这正是您凭经验发现的恢复程序预期行为的方法。time.sleep()这是一个称为线程饥饿的典型问题的示例，可以通过使用多处理库来解决。这会带来更多的复杂性，但会将您的 CPU 密集型计算和基于事件的轻量级接口分开在不同的进程中，从而解决您的问题。

Answer 2

我研究了使用多处理而不是线程。该multiprocessing.Pipe对象确保了双工通信并使整个事情变得更加顺畅。我现在还可以确保模拟的实时运行。两边的每个更新循环，只需使用send()andrecv()命令。尚未测试边缘情况，但似乎工作顺利。我将修改添加到上面发布的示例中：import timeimport arcadefrom multiprocessing import Process, Pipefrom math import sin, piclass DisplayWindow(arcade.Window):    def __init__(self, connection: Pipe):        super().__init__(500, 500)        self.connection: Pipe = connection    # multiprocessing.Pipe        self.position: float = 0               # GUI Display state        self.user_input: float = 1.0           # Input to simulation        self.FPS: float = 0                    # Frames per second estimation    def on_update(self, delta_time: float):        self.FPS = 1. / delta_time        # Communicate with simulation:        self.connection.send(self.user_input)        self.position = self.connection.recv()    def on_draw(self):        arcade.start_render()        arcade.draw_text(f'FPS: {self.FPS:0.0f}', 20, 20, arcade.color.WHITE)        arcade.draw_point(self.position, self.height/2, arcade.color.WHITE, 10)    def on_key_release(self, symbol: int, modifiers: int):        if symbol == arcade.key.W:            self.user_input = 1.8        elif symbol == arcade.key.S:            self.user_input = 0.3# Separate Process target to simulate physics:def simulation(connection: Pipe):    t_0 = time.time()    while True:        freq = connection.recv() * 2 * pi       # Receive GUI user input        t = time.time() - t_0        x = sin(freq * t) * 250 + 250        connection.send(x)                      # Send state to GUIdef main():    parent_con, child_con = Pipe()    display_window = DisplayWindow(connection=parent_con)    physics = Process(target=simulation, args=(child_con,), daemon=True)    physics.start()    arcade.run()    physics.terminate()    return 0if __name__ == '__main__':    main()