多线程函数联动问题：如何让StopStart控制NormalFire执行逻辑

我看了你遇到的线程联动控制问题，核心是几个细节没处理好，导致NormalFire没法响应fire变量的变化。咱们先梳理下问题根源，再给出修复后的代码和更优雅的类实现方案：

问题根源分析 #

• 线程创建方式错误：你之前写Thread(target=NormalFire(fire))的时候，是直接调用了NormalFire函数，把它的返回值（这里是None）当作线程目标，这会导致线程根本没按预期启动，应该直接传函数名，不需要加括号调用。
• 全局变量未正确声明：在函数里修改全局变量（比如fire、hshtag）时，必须先声明global 变量名，否则Python会把它当作局部变量处理，根本不会修改全局的那个变量——这就是为什么你在x函数里设置fire=True，y函数却看不到变化的原因。
• 键盘监听循环太占用CPU：原代码里的while循环一直跑，没加休眠，会导致CPU占用过高，最好加个小延迟。

修复后的函数式实现 #

import time
import keyboard
from threading import Thread

# 全局变量
hshtag = 0
done = False
fire = False

def StopStart():
    global hshtag, fire
    while not done:
        if keyboard.is_pressed('#'):
            hshtag += 1
            # 切换fire状态：奇数次按下启动，偶数次停止
            fire = hshtag % 2 != 0
            # 加个小延迟，避免短时间内重复触发#键
            time.sleep(0.2)
        time.sleep(0.01)

def NormalFire():
    global fire, done
    while not done:
        if fire:
            # 这里替换成你的实际耗时任务逻辑
            print("执行#do x任务...")
            # 模拟任务耗时1秒，实际任务完成后才会检查fire状态
            time.sleep(1)
        else:
            # 空闲时休眠，减少CPU占用
            time.sleep(0.01)

# 正确创建线程：直接传函数名，不要提前调用
t1 = Thread(target=StopStart)
t2 = Thread(target=NormalFire)

t1.start()
t2.start()

# 新增退出逻辑：按q键停止所有线程
try:
    while not done:
        if keyboard.is_pressed('q'):
            done = True
            break
        time.sleep(0.01)
except KeyboardInterrupt:
    done = True

# 等待线程结束
t1.join()
t2.join()

这个版本的改进点：

• 正确声明了global变量，确保函数能修改全局的fire和hshtag
• 线程创建时直接传函数名，避免了提前执行函数的错误
• 键盘监听时加了延迟，防止短时间内重复触发#键
• 耗时任务执行时，即使fire被设为False，当前任务也会完成后再停止，完全符合你的需求

更优雅的基于类的实现 #

如果想避免全局变量的混乱，用类来封装状态和逻辑会更清晰：

import time
import keyboard
from threading import Thread

class FireController:
    def __init__(self):
        self.hshtag = 0
        self.done = False
        self.fire = False

    def stop_start(self):
        while not self.done:
            if keyboard.is_pressed('#'):
                self.hshtag += 1
                self.fire = self.hshtag % 2 != 0
                time.sleep(0.2)
            time.sleep(0.01)

    def normal_fire(self):
        while not self.done:
            if self.fire:
                # 替换成你的实际耗时任务
                print("执行#do x任务...")
                time.sleep(1)  # 模拟任务耗时
            else:
                time.sleep(0.01)

    def run(self):
        # 创建并启动线程
        t1 = Thread(target=self.stop_start)
        t2 = Thread(target=self.normal_fire)
        t1.start()
        t2.start()

        # 退出逻辑
        try:
            while not self.done:
                if keyboard.is_pressed('q'):
                    self.done = True
                    break
                time.sleep(0.01)
        except KeyboardInterrupt:
            self.done = True

        # 等待线程结束
        t1.join()
        t2.join()

if __name__ == "__main__":
    controller = FireController()
    controller.run()

类实现的优势：

• 用实例变量代替全局变量，避免了全局变量的混乱
• 所有逻辑封装在类中，代码更易维护和扩展
• 各个方法共享实例状态，不需要额外的global声明

内容的提问来源于stack exchange，提问作者S.Parry