这个问题我之前帮别人解决过类似的，本质是Paho MQTT客户端的内部消息队列在搞鬼——默认情况下，当你的消息回调函数还在执行时，新收到的MQTT消息会被存进队列里排队，等当前回调跑完就挨个执行，所以连续发3条消息就会连跑三次。给你几个实用的解决方案，看你需求选：

如果你的场景只关心最新的指令，不需要处理中间积压的消息，这个方案最适合。核心思路是用单独线程处理消息，回调函数只负责更新“最新消息”变量，处理线程只在空闲时处理最新的消息，中间的旧消息会被直接覆盖。

import paho.mqtt.client as mqtt
import threading
import time
# 替换成你实际展示图片的依赖，比如PIL、pygame等

# 全局变量：保存最新消息+处理状态锁
latest_msg = None
is_processing = False
lock = threading.Lock()

def on_message(client, userdata, msg):
    global latest_msg
    # 收到新消息时，只更新最新消息，不直接执行处理逻辑
    with lock:
        latest_msg = msg.payload.decode()
        print(f"捕获新消息: {latest_msg}")

def message_processor():
    global latest_msg, is_processing
    while True:
        current_task = None
        # 安全获取最新消息并标记为处理中
        with lock:
            if latest_msg is not None and not is_processing:
                current_task = latest_msg
                latest_msg = None
                is_processing = True
        
        if current_task:
            try:
                # 替换成你的实际处理逻辑：展示图片5秒
                print(f"开始处理任务: {current_task}")
                # 示例：假设用系统命令展示图片
                # os.system(f"feh --auto-zoom image_{current_task}.png & sleep 5; pkill feh")
                time.sleep(5)  # 模拟展示图片的耗时
                print("任务处理完成")
            finally:
                # 处理完成后释放状态锁
                with lock:
                    is_processing = False
        time.sleep(0.1)  # 避免空转占用CPU

# MQTT客户端初始化
client = mqtt.Client()
client.on_message = on_message

# 连接你的MQTT Broker，替换成实际地址和端口
client.connect("your_broker_ip", 1883, 60)

# 启动消息处理线程（后台守护线程）
processing_thread = threading.Thread(target=message_processor, daemon=True)
processing_thread.start()

# 订阅目标主题
client.subscribe("your/target/topic")

# 保持客户端运行
client.loop_forever()

如果允许丢失处理期间的消息，这个方案最简单直接：开始处理消息时暂时取消订阅，处理完成后重新订阅。这样在处理图片的5秒内，客户端不会接收新消息，也就不会产生排队。

import paho.mqtt.client as mqtt
import time

TARGET_TOPIC = "your/target/topic"

def on_message(client, userdata, msg):
    message = msg.payload.decode()
    print(f"收到消息: {message}")
    
    # 暂停订阅主题
    client.unsubscribe(TARGET_TOPIC)
    
    try:
        # 执行你的图片展示逻辑
        print(f"开始展示图片，对应消息: {message}")
        time.sleep(5)
        print("图片展示完成")
    finally:
        # 处理完成后重新订阅
        client.subscribe(TARGET_TOPIC)

# MQTT客户端配置
client = mqtt.Client()
client.on_message = on_message
client.connect("your_broker_ip", 1883, 60)
client.subscribe(TARGET_TOPIC)

client.loop_forever()

⚠️ 注意：如果你的MQTT QoS设置为1/2，Broker会在你取消订阅期间缓存消息，重新订阅后会一次性收到所有缓存的消息，这种情况不建议用这个方案。

如果需要处理所有消息，但不想连续执行（比如希望任务间有间隔），可以用容量为1的队列，每次收到新消息时清空队列，确保队列里永远只有最新的任务。

import paho.mqtt.client as mqtt
import queue
import threading
import time

# 容量为1的任务队列，只保留最新消息
msg_queue = queue.Queue(maxsize=1)

def on_message(client, userdata, msg):
    message = msg.payload.decode()
    print(f"收到新消息: {message}")
    # 清空队列，丢弃旧消息
    with msg_queue.mutex:
        msg_queue.queue.clear()
    try:
        msg_queue.put_nowait(message)
    except queue.Full:
        pass  # 清空后不会触发满队列异常

def worker():
    while True:
        task = msg_queue.get()
        try:
            print(f"开始处理任务: {task}")
            time.sleep(5)  # 模拟图片展示
            print("任务处理完成")
        finally:
            msg_queue.task_done()

# MQTT客户端配置
client = mqtt.Client()
client.on_message = on_message
client.connect("your_broker_ip", 1883, 60)
client.subscribe("your/target/topic")

# 启动工作线程
threading.Thread(target=worker, daemon=True).start()

client.loop_forever()

内容的提问来源于stack exchange，提问作者sporc