如何实现Django视图同一时间仅允许单次访问？

你要的是视图级的全局访问锁，不是用户session级的限制——session是每个用户专属的，没法实现“同一时间只有一个用户访问该页面”的全局限制。下面给你两种可行的实现方案，都支持匿名和认证用户：

方案一：基于缓存的基础全局锁 #

利用Django的缓存系统实现全局锁，缓存是跨用户、跨进程的，能满足全局唯一访问的需求。

步骤1：写一个复用的装饰器 #

from django.core.cache import cache
from django.http import HttpResponseForbidden

def single_access_only(view_func):
    def wrapped_view(request, *args, **kwargs):
        # 用视图函数名作为锁的唯一标识，确保不同视图的锁不冲突
        lock_key = f"view_lock:{view_func.__name__}"
        # 尝试添加锁（cache.add只有key不存在时才会成功，原子操作），设置超时时间（比如30秒）
        lock_acquired = cache.add(lock_key, "locked", timeout=30)
        
        if not lock_acquired:
            # 锁已被占用，返回拒绝响应
            return HttpResponseForbidden("该页面当前正在被访问，请稍后再试")
        
        try:
            # 执行原视图逻辑
            response = view_func(request, *args, **kwargs)
            return response
        finally:
            # 不管视图执行成功还是报错，都释放锁
            cache.delete(lock_key)
    return wrapped_view

步骤2：给目标视图加装饰器 #

from django.http import HttpResponse

@single_access_only
def restricted_page(request):
    # 这里写你的视图业务逻辑
    return HttpResponse("当前只有你在访问这个页面")

注意事项 #

• 超时时间要根据页面操作时长调整：如果用户在页面停留超过超时时间，锁会自动释放，避免因用户异常退出导致锁一直占用。
• 生产环境用分布式缓存：如果是多进程/多服务器部署，别用默认的LocMemCache（它的锁只在当前进程/服务器生效），换成Redis或Memcached才能实现全局锁。

方案二：支持持有者刷新的增强版锁 #

如果需要允许持有锁的用户刷新页面（不被自己的锁挡住），可以结合用户标识（认证用户用ID，匿名用户用session_key）来做：

from django.core.cache import cache
from django.http import HttpResponseForbidden

def single_access_with_refresh(view_func):
    def wrapped_view(request, *args, **kwargs):
        lock_key = f"view_lock:{view_func.__name__}"
        # 获取当前用户的唯一标识：认证用户用ID，匿名用户用session_key（Django自动生成）
        user_id = request.user.id if request.user.is_authenticated else request.session.session_key
        
        current_lock_holder = cache.get(lock_key)
        if current_lock_holder:
            if current_lock_holder == user_id:
                # 是锁的持有者，允许访问（比如刷新页面）
                return view_func(request, *args, **kwargs)
            else:
                return HttpResponseForbidden("该页面当前正在被其他用户访问，请稍后再试")
        else:
            # 没有锁，获取并设置超时
            cache.set(lock_key, user_id, timeout=30)
            try:
                return view_func(request, *args, **kwargs)
            finally:
                # 只有锁的持有者才能释放锁，防止其他用户误删
                if cache.get(lock_key) == user_id:
                    cache.delete(lock_key)
    return wrapped_view

这个方案既保留了全局唯一访问的限制，又不会挡住持有锁的用户自己刷新页面，更符合实际使用场景。

核心逻辑说明 #

你的需求本质是全局资源互斥访问，和用户session无关——session是用户的专属存储，没法用来控制跨用户的全局访问。用缓存实现锁是最直接的方式，因为缓存的操作是原子性的，能避免并发请求导致的锁竞争问题。

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