同步Django应用调用长耗时外部服务的防阻塞方案咨询

以下是几种针对性的解决方案，按实现复杂度和适用场景排序：

1. 增加Gunicorn工作进程数量 #

这是最快速的缓解方案，通过多进程分摊阻塞压力：

• 原理：单进程模式下，一个慢请求会占满唯一的工作进程，导致后续请求全部排队。增加进程数后，多个请求可由不同进程并行处理。
• 操作：启动Gunicorn时调整--workers参数，建议设置为2*CPU核心数+1，比如4核CPU用--workers=9，示例命令：

  gunicorn --workers=4 your_project.wsgi:application
  

• 局限性：仅能缓解，若大量慢请求同时涌入，仍会占满所有进程。

2. 改用异步HTTP客户端+DRF异步视图 #

将同步的外部调用改为异步执行，避免阻塞线程：

• 前提：确保Django版本≥3.1、DRF版本≥3.12，支持异步视图；安装异步HTTP客户端aiohttp：

  pip install aiohttp
  

• 实现示例：

  from rest_framework.views import APIView
  from rest_framework.response import Response
  import aiohttp
  
  class SlowExternalCallAPI(APIView):
      async def get(self, request):
          # 异步发起外部请求
          async with aiohttp.ClientSession() as session:
              async with session.get(
                  "https://slow-external-service.com/api",
                  params=request.query_params.dict()
              ) as resp:
                  data = await resp.json()
          return Response(data)
  

• 配套调整：Gunicorn需使用异步工作器，比如uvicorn.workers.UvicornWorker，安装uvicorn后启动命令：

  gunicorn --worker-class=uvicorn.workers.UvicornWorker your_project.wsgi:application
  

3. 引入任务队列异步处理（推荐） #

彻底将慢请求逻辑剥离到后台，API仅负责触发任务和返回状态：

• 技术栈：使用Celery作为任务队列，搭配Redis或RabbitMQ作为消息中间件。
• 步骤：
  1. 安装依赖：

     pip install celery redis
     

  2. 配置Celery（项目根目录创建celery.py）：

     import os
     from celery import Celery
     
     os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project.settings')
     app = Celery('your_project')
     app.config_from_object('django.conf:settings', namespace='CELERY')
     app.autodiscover_tasks()
     

  3. 定义后台任务（app/tasks.py）：

     from celery import shared_task
     import requests
     
     @shared_task
     def call_slow_external_service(params):
         resp = requests.get("https://slow-external-service.com/api", params=params)
         return resp.json()
     

  4. 修改API视图，触发任务并返回任务ID：

     from rest_framework.views import APIView
     from rest_framework.response import Response
     from .tasks import call_slow_external_service
     
     class SlowExternalCallAPI(APIView):
         def get(self, request):
             task = call_slow_external_service.delay(request.query_params.dict())
             return Response({"task_id": task.id, "status": "处理中"})
     

  5. 新增任务状态查询API：

     from celery.result import AsyncResult
     from rest_framework.views import APIView
     from rest_framework.response import Response
     
     class TaskStatusAPI(APIView):
         def get(self, request, task_id):
             result = AsyncResult(task_id)
             if result.ready():
                 return Response({"status": "完成", "data": result.get()})
             return Response({"status": "处理中"})
     

  6. 启动Celery Worker：

     celery -A your_project worker --loglevel=info
     

• 优势：完全避免API阻塞，支持超长时间的外部调用，可配合Websocket或推送机制实现主动通知。

4. 使用线程池处理同步调用 #

在同步视图中用线程池异步执行外部请求，减少主线程阻塞：

• 实现示例：

  from rest_framework.views import APIView
  from rest_framework.response import Response
  import requests
  from concurrent.futures import ThreadPoolExecutor
  
  # 初始化线程池，设置最大线程数
  executor = ThreadPoolExecutor(max_workers=4)
  
  class SlowExternalCallAPI(APIView):
      def get(self, request):
          # 提交外部请求到线程池
          future = executor.submit(
              requests.get,
              "https://slow-external-service.com/api",
              params=request.query_params.dict()
          )
          # 等待线程执行结果
          resp = future.result()
          return Response(resp.json())
  

• 局限性：线程数量有限，大量慢请求仍会耗尽线程资源，适合中等耗时的外部调用。

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