这个问题我遇到过。核心原因是websocket-client的回调函数（比如on_message）默认在它自己的线程里运行，你直接在主线程或者其他地方调用发送函数会出线程安全问题。

最直接的解决办法是用一个线程安全的队列（比如queue.Queue）来做通信。让on_message回调只负责把收到的消息放进队列，然后你的主逻辑从队列里取消息处理。反过来，你要发送消息时，也把消息放进另一个发送队列，然后让websocket-client在一个专门的发送线程里从这个队列取消息发出去。

下面是一个完整的例子，展示了怎么用队列来解耦接收、发送和你的主业务逻辑：

import threading
import queue
import time
from websocket import WebSocketApp

class WebSocketManager:
    def __init__(self, url):
        self.url = url
        self.ws = None
        self.receive_queue = queue.Queue()
        self.send_queue = queue.Queue()
        self.connected = False
        
    def on_message(self, ws, message):
        """收到消息时，只放入接收队列"""
        self.receive_queue.put(message)
        
    def on_open(self, ws):
        """连接建立后，启动发送线程"""
        self.connected = True
        self.ws = ws
        # 启动发送线程
        send_thread = threading.Thread(target=self._send_worker, daemon=True)
        send_thread.start()
        print("连接已建立，发送线程已启动")
        
    def on_close(self, ws, close_status_code, close_msg):
        self.connected = False
        print("连接关闭")
        
    def _send_worker(self):
        """发送工作线程，专门从发送队列取消息并发送"""
        while self.connected:
            try:
                # 阻塞等待发送队列中的消息
                message = self.send_queue.get(timeout=1)
                if self.ws and self.connected:
                    self.ws.send(message)
                    print(f"已发送: {message}")
            except queue.Empty:
                continue
            except Exception as e:
                print(f"发送出错: {e}")
                
    def send_message(self, message):
        """外部调用此方法发送消息（线程安全）"""
        if self.connected:
            self.send_queue.put(message)
        else:
            print("未连接，无法发送")
            
    def get_message(self):
        """外部调用此方法获取接收到的消息"""
        try:
            return self.receive_queue.get_nowait()
        except queue.Empty:
            return None
            
    def connect(self):
        """启动WebSocket连接"""
        self.ws = WebSocketApp(
            self.url,
            on_open=self.on_open,
            on_message=self.on_message,
            on_close=self.on_close
        )
        # 在后台线程运行WebSocket
        wst = threading.Thread(target=self.ws.run_forever, daemon=True)
        wst.start()

# 使用示例
if __name__ == "__main__":
    manager = WebSocketManager("wss://echo.websocket.events")
    manager.connect()
    
    # 等待连接建立
    time.sleep(2)
    
    # 外部发送消息
    manager.send_message("Hello WebSocket!")
    
    # 主循环处理接收到的消息
    for i in range(5):
        msg = manager.get_message()
        if msg:
            print(f"收到消息: {msg}")
        time.sleep(1)

这个模式的关键点：

1. on_message回调里不做复杂处理，只把消息丢进接收队列
2. 单独开一个发送线程，专门从发送队列取消息并通过ws.send()发送
3. 外部通过send_message()方法把要发的消息放进发送队列，这样就安全了
4. 通过get_message()从接收队列取消息处理

这样设计之后，你的业务逻辑和WebSocket的收发就完全解耦了，可以从任何地方安全地调用发送方法。

总结：用队列做中间层来解耦收发逻辑。

加一个线程 传递 Ws 对象即可