Python 进程类型错误：无法腌制'_thread.lock' object

Question

这里有点撞墙。 基本上我有一个 python 程序可以从内部启动多个机器人，我试图将每个机器人作为一个单独的进程启动。 所以我创建了一个 class 来保存所有实例，以便我以后可以在需要时停止它们。

在那个 class 中，我有一个启动进程的方法。

def start_new_bot(self, bot_id, commission):
            # Other things calculations...

            trader = BotTrader(
                bot=db_bot,
                commission=commission,
                symbol_filters=symbol_filters,
                api_key=api_key,
                api_secret=api_sec,
                api_pass=api_pass,
            )

            process = Process(target=trader.start_trading)
            self.instances.append(process)
            process.start()
            
            process.join()

我的 BotTrader class 看起来像这样：

class BotTrader():
    def __init__(
        self,
        bot,
        commission,
        symbol_filters,
        api_key,
        api_secret,
        api_pass="",
    ):
        # Bot options
        self.accumulate_wallet_profit = bot["accumulate_wallet_profit"]
        

        for filter in symbol_filters:
            if filter["filterType"] == "LOT_SIZE":
                self.LOT_SIZE = filter["stepSize"].find("1") - 1
            elif filter["filterType"] == "PRICE_FILTER":
                self.STEP_SIZE = filter["tickSize"].find("1") - 1

        self.trade_manager = TradeManager(
            bot_obj=self.db_bot,
            step_size=self.STEP_SIZE,
            lot_size=self.LOT_SIZE,
            commission=commission,
            logger=self.logger,
        )
        self.orders = Orders(
            exchange=bot["exchange"],
            api_key=api_key,
            api_secret=api_secret,
            api_pass=api_pass,
            step_size=self.STEP_SIZE,
            lot_size=self.LOT_SIZE,
            commission=commission,
        )
        # order book
        self.orderbook_manager = OrderBookManager(
            bot_obj=self.db_bot,
            trade_symbol=self.TRADE_SYMBOL,
            logger=self.logger,
        )
        

    def start_trading(self):
        try:
            websocket.enableTrace(False)

            self.orderbook_manager.initialize()

            socket_url = (
                    "wss://stream.binance.com:9443/ws/"
                    + self.TRADE_SYMBOL.lower()
                    + "@kline_"
                    + self.INTERVAL
                )
            self.WEBSOCKET = websocket.WebSocketApp(
                    url=socket_url,
                    on_message=self.on_websocket_message,
                    on_error=self.on_error,
                )
            self.WEBSOCKET.run_forever()
 
        except SysCallError as e:
            sentry_sdk.capture_exception(e)

当 process.start() 被调用时，我得到错误TypeError: cannot pickle '_thread.lock' object不知道从哪里开始解决这个问题。

在我使用线程之前。 它奏效了，BotTrader 是一个守护线程

trader = BotTrader(
                bot=db_bot,
                commission=commission,
                symbol_filters=symbol_filters,
                api_key=api_key,
                api_secret=api_sec,
                api_pass=api_pass,
            )

            trader.start()
            self.instances.append(trader)


class BotTrader(threading.Thread):
     super(BotTrader, self).__init__()
     self.daemon = True

     def run(self):
       try:
          if self.bot_running:
              self.start_trading()
       except Exception as e:
          sentry_sdk.capture_exception(e)
          self.print_message(
            f"Encountered fatal error in run method: 

Answer 1

我会回避无法将BotTrader实例发送到另一个进程的问题，只需在将要使用它的进程中创建它：

@staticmethod
def bot_proc_target(bot_id, commission):
    trader = BotTrader(
                bot=db_bot,
                commission=commission,
                symbol_filters=symbol_filters,
                api_key=api_key,
                api_secret=api_sec,
                api_pass=api_pass,
            )
    trader.start_trading()

def start_new_bot(self, bot_id, commission):
            # Other things calculations...

            process = Process(target=self.bot_proc_target, args=(bot_id, commission))
            self.instances.append(process)
            process.start()
            process.join()