Django多Worker部署：内存共享与_thread.lock序列化问题求解

方案1：自定义User类的Pickle序列化逻辑 #

问题核心是_thread.lock无法被pickle序列化，你可以通过重写User类的__getstate__和__setstate__方法，在序列化时跳过锁对象，反序列化时重新初始化锁，无需改动原有线程逻辑：

class CustomUser(AbstractUser):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.lock = _thread.lock()
        # 初始化你的线程相关属性

    def __getstate__(self):
        # 复制实例状态，移除不可序列化的lock对象
        state = self.__dict__.copy()
        del state['lock']
        return state

    def __setstate__(self, state):
        # 恢复实例状态，重新创建锁对象
        self.__dict__.update(state)
        self.lock = _thread.lock()
        # 可根据恢复的用户状态重启线程逻辑

修改后User实例可正常序列化存入Redis，反序列化时自动重建锁，线程逻辑能基于恢复的状态继续运行。

方案2：用进程间共享内存存储核心状态 #

如果不想依赖Redis，可使用Pythonmultiprocessing模块的共享内存机制，只共享用户核心数据，而非整个User实例：

• 启动时用multiprocessing.Manager()创建共享字典，存储用户的非线程相关状态。
• 每个Worker进程内部维护独立的线程和锁，通过共享字典同步数据。

示例代码：

# 项目启动阶段初始化共享管理器
from multiprocessing import Manager

shared_user_state = Manager().dict()

# Worker内部的线程逻辑
def user_thread_logic(user_id):
    # 从共享内存获取用户状态
    user_state = shared_user_state.get(user_id, {})
    lock = _thread.lock()
    # 基于状态执行线程逻辑，更新后同步回共享内存
    with lock:
        # 修改user_state
        shared_user_state[user_id] = user_state

这种方式避免了序列化线程对象，每个Worker独立维护锁和线程，既保证线程复用，又解决跨进程共享问题。

方案3：重构线程与用户状态的耦合 #

把User类中的线程逻辑抽离到独立的线程管理器，每个Worker进程内部维护线程缓存，以用户ID为键存储线程实例：

• 用户登录状态（非线程相关）存在Redis用于身份验证。
• 收到请求时，Worker先检查本地线程缓存，不存在则基于Redis中的用户状态创建线程并存入缓存。

示例逻辑：

# 每个Worker进程的本地线程缓存
local_thread_cache = {}
cache_lock = _thread.lock()

def get_user_thread(user_id):
    with cache_lock:
        if user_id not in local_thread_cache:
            # 从Redis获取用户状态
            user_state = redis_client.get(f"user:{user_id}")
            # 创建并启动线程
            thread = threading.Thread(target=thread_logic, args=(user_state,))
            thread.daemon = True
            thread.start()
            local_thread_cache[user_id] = thread
        return local_thread_cache[user_id]

此设计下线程实例无需跨进程传递，每个Worker独立维护线程，既避开序列化问题，又能复用线程，无需每次请求重建。

注意事项 #

• Daphne的Worker进程完全隔离，不要尝试跨进程直接共享线程对象。
• 所有共享数据的读写必须加锁，保证线程安全。
• 使用共享内存时，需在Worker退出时清理资源，避免内存泄漏。

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