深入理解Django多进程部署下的全局变量行为

# myapp/views.py 或 settings.py 附近
my_global_dict = {} # 这是一个全局字典，初始为空

def view1(request):
    """
    此视图尝试修改全局字典。
    """
    my_global_dict["key0"] = "instance_of_myClass" # 假设这里存储了一个类实例
    print(f"View1 (PID: {os.getpid()}) - my_global_dict after modification: {my_global_dict}")
    return HttpResponse("View1: Global dict modified.")

def view2(request):
    """
    此视图尝试访问全局字典。
    """
    print(f"View2 (PID: {os.getpid()}) - my_global_dict before access: {my_global_dict}")
    if "key0" in my_global_dict:
        value = my_global_dict["key0"]
        return HttpResponse(f"View2: Found key0 with value: {value}")
    else:
        return HttpResponse("View2: Key0 not found in global dict (or dict is empty).")

# 假设Gunicorn配置了多个worker，例如 gunicorn --workers 3 myproject.wsgi:application
# 1. 访问 /view1，请求可能被 worker A 处理，worker A 的 my_global_dict 变为 {"key0": "..."}
# 2. 接着访问 /view2，请求可能被 worker B 处理，worker B 的 my_global_dict 仍然是 {}
# 结果就是 view2 无法看到 view1 的修改。

# settings.py

CACHES = {
    "default": {
        "BACKEND": "django.core.cache.backends.memcached.PyMemcacheCache", # 或者 'django.core.cache.backends.memcached.MemcachedCache'
        "LOCATION": "127.0.0.1:11211", # Memcached服务器地址和端口
        "TIMEOUT": 300, # 缓存超时时间，单位秒
        "KEY_PREFIX": "my_app_cache_", # 缓存键前缀，防止与其他应用冲突
    }
    # 你也可以配置其他缓存，例如 Redis:
    # "redis": {
    #     "BACKEND": "django.core.cache.backends.redis.RedisCache",
    #     "LOCATION": "redis://127.0.0.1:6379/1",
    #     "OPTIONS": {
    #         "CLIENT_CLASS": "django_redis.client.DefaultClient",
    #     }
    # }
}

# myapp/views.py
from django.core.cache import cache
from django.http import HttpResponse
import os

# 假设 myClass 是你的某个业务类
class MyClass:
    def __init__(self, value="default"):
        self.value = value
    def __str__(self):
        return f"MyClass(value='{self.value}')"

def view1_with_cache(request):
    """
    此视图将数据存储到缓存中。
    """
    key = "my_shared_data_key"
    instance = MyClass(value=f"data_from_view1_pid_{os.getpid()}")
    cache.set(key, instance, timeout=300) # 存储数据，设置5分钟过期
    print(f"View1 (PID: {os.getpid()}) - Stored '{instance}' in cache with key '{key}'.")
    return HttpResponse("View1: Data stored in cache.")

def view2_with_cache(request):
    """
    此视图从缓存中检索数据。
    """
    key = "my_shared_data_key"
    cached_data = cache.get(key)
    print(f"View2 (PID: {os.getpid()}) - Retrieved from cache with key '{key}': {cached_data}")
    if cached_data:
        return HttpResponse(f"View2: Found shared data in cache: {cached_data}")
    else:
        return HttpResponse("View2: Shared data not found in cache.")

# 1. 访问 /view1_with_cache，无论哪个 worker 处理，数据都会被写入到共享的 Memcached 服务中。
# 2. 接着访问 /view2_with_cache，无论哪个 worker 处理，它都能从 Memcached 中读取到 view1 写入的数据。