解锁性能：Django 异步支持指南

性能优化是构建 Web 应用程序的一个重要方面，开发人员一直在寻求使他们的应用程序更快、响应更快的方法。

在 Django 的世界里，异步支持已成为提升性能的有力工具。通过采用异步编程，开发人员可以充分利用非阻塞操作、更高的可扩展性和更强大的响应能力。

无论您是异步编程新手还是经验丰富的 Django 开发人员，本指南都将为您提供宝贵的见解、实用技巧和真实示例，以帮助您利用 Django 中异步支持的强大功能。

让我们首先了解什么是异步编程。

理解异步编程

异步编程（Async Programming）是一种允许非阻塞执行代码的编程范式。它提供了一种编写可并发执行多个任务的程序的方法，无需等待每个任务完成后再执行下一个任务。

在传统的同步编程中，代码按顺序执行，每个操作都会阻塞程序直到其完成。这会导致效率低下，尤其是在处理需要等待外部资源的操作（例如网络请求或数据库查询）时。程序通常会在这些等待期间处于空闲状态，浪费宝贵的时间。

另一方面，异步编程引入了协程和事件驱动执行的概念。协程是可以暂停和恢复的函数或方法，允许其他代码同时运行。事件循环充当协调器，管理协程的执行，调度它们并发运行，并根据需要在它们之间切换。

使用异步编程，当任务遇到通常会阻塞的操作时，它会暂停并允许事件循环切换到另一个可以继续执行的任务。这样，程序可以在等待操作完成的同时继续执行其他任务，从而有效利用系统资源并提高整体性能和响应能力。

异步编程的主要优点是提高了响应速度和资源利用率。通过避免不必要的等待时间，程序可以执行其他任务或响应事件，从而更好地利用可用资源。

以下是同步和异步编程范例的简要比较：

现在，在深入研究异步编程之前，让我们首先理清与之相关的术语和基本概念，而不考虑任何特定的语言或框架。

术语和基本概念

协程

协程是异步编程的基石。它们是可以在执行过程中的特定时间点暂停和恢复的函数或方法。协程允许协作式多任务处理，通常使用编程语言提供的特殊语法或关键字来定义。

想象一下，一位厨师在繁忙的餐厅厨房里做饭。他开始准备一道菜，但突然意识到需要煨一会儿。于是他没有等待，而是暂停，换到另一道菜，然后继续烹饪。这种暂停和切换任务的能力，体现在异步编程中。

事件循环

事件循环是异步编程的核心组件。它负责管理和协调协程的执行。事件循环会持续检查事件（例如 I/O 完成或计时器到期），并调度相应的协程执行。它确保协程并发高效地运行。

想象一下会议上的活动协调员。协调员会接收会场内各种事件的通知，例如演讲者结束演讲或研讨会开始。协调员会维护一个时间表，并确保每个事件都得到适当的管理和执行，就像事件循环在异步编程中管理协程的执行一样。

非阻塞 I/O

非阻塞 I/O 操作在异步编程中至关重要。它们允许在不阻塞程序执行的情况下发起 I/O 操作。发起非阻塞 I/O 操作后，程序可以在等待 I/O 操作完成的同时继续执行其他任务或协程。这种方法可以最大限度地提高资源利用率和响应速度。

想象一下酒店接待员如何协助客人处理他们的请求。当一位客人要求额外的毛巾时，接待员不会等毛巾送达后再去服务下一位客人。相反，接待员会先提出毛巾请求，然后在等待毛巾送达的同时继续为其他客人提供服务。这类似于非阻塞 I/O，程序会发起 I/O 操作，并在等待该操作完成的同时继续执行其他任务。

承诺/未来

Promises 或 Future 是表示异步操作结果的对象。它们允许处理可能无法立即获取的值。Promises 可以在协程中等待，当它们所代表的操作完成后，协程将使用结果继续执行。Promises 提供了一种处理异步任务结果的方法。

想象一下，您在线订购包裹并收到一个追踪号。追踪号就像一个承诺或未来。它代表订单的结果，但您不会立即收到包裹。您可以在等待包裹送达的同时继续进行其他活动。包裹送达后，您可以处理包裹或继续执行后续任务。承诺/未来提供了类似的机制，用于在异步编程中处理异步操作的结果。

回调

回调是响应特定事件或异步操作完成而执行的函数或代码片段。它们通常用于处理异步任务的结果或错误。回调允许定义在事件发生时执行的自定义逻辑，从而为异步编程提供灵活性。

想象一下一个音乐节，不同的舞台同时举办演出。每个舞台都有自己的时间表，音乐节的参与者可以选择观看哪些演出。观看演出就像注册回拨一样。

演出结束后，观众会收到通知，并可自行决定如何应对，是移至其他舞台，还是留下观看下一场演出。异步编程中的回调机制与此类似，允许在事件或异步操作完成时触发特定操作。

现在，让我们转到 Django 中的异步支持。

Django 中的异步支持

在 Django 3.1 之前，该框架主要支持同步（阻塞）执行。然而，从 Django 3.1 开始，异步支持作为一项实验性功能引入。启用异步支持后，Django 应用程序可以利用异步编程范式，并享受非阻塞 I/O 和并发执行的优势。

Django 现在允许您定义异步视图、数据库操作（主要是）和中间件，稍后我们将详细讨论这些内容。但在深入探讨之前，我们应该先了解一下什么是 ASGI 和 HTTPX，以及为什么需要它们来在 Django 应用程序中启用异步支持。

什么是 ASGI？

ASGI（异步服务器网关接口）协议是一种规范，它定义了 Web 服务器与 Python Web 应用程序或框架之间的接口，从而能够在 Web 开发环境中实现异步操作。

传统上，Python 中的 Web 应用程序使用类似WSGI（Web 服务器网关接口）之类的同步服务器提供服务。然而，同步服务器在处理并发和高效扩展方面能力有限，尤其是在处理长时间运行或 I/O 密集型操作时。这促成了 ASGI 协议的开发，该协议通过引入异步功能来解决这些限制。

ASGI 协议使 Web 服务器能够以异步方式与 Python 应用程序或框架通信。它定义了一个标准化接口，允许交换 HTTP 请求和响应，以及处理其他类型的异步事件，例如 WebSocket 或服务器发送的事件。

以下是 WSGI 和 ASGI 的快速比较：

注意：WSGI 应用程序可以使用兼容层在 ASGI 服务器上运行，但它们不会充分利用 ASGI 提供的异步功能。

为什么 Django 需要 ASGI 来支持异步？

Django 需要 ASGI 来实现异步支持，才能充分发挥异步编程的优势。ASGI 的异步特性使 Django 能够通过将工作负载分配到多个工作进程或机器上来实现水平扩展。

此外，使用 ASGI，Django 可以利用 Python 日益壮大的异步库和工具生态系统。ASGI 支持与支持异步的数据库库、缓存后端和其他服务集成。这种灵活性使 Django 开发人员能够充分利用异步库的强大功能，并设计出能够利用其功能的应用程序。

此外，ASGI 的设计使其能够向后兼容 Django 一直以来所依赖的现有 WSGI 标准。这种兼容性使 Django 应用程序能够逐步过渡到 ASGI，而不会破坏现有的代码库。ASGI服务器可以同时运行 WSGI 和 ASGI 应用程序，从而更轻松地在 Django 应用程序中逐步引入异步支持。

Uvicorn和Daphne都是 ASGI 服务器实现，可以与 Django 一起使用，通过 ASGI 协议为你的应用程序提供服务。Uvicorn 构建于 Djangouvloop库之上，该库是基于 libuv 的事件循环的快速实现；而 Daphne 则作为 Django Channels 项目的一部分进行维护，旨在满足 Django 应用程序使用异步功能（例如实时更新、双向通信和长连接）的独特需求。

以下是 Uvicorn 和 Daphne 主要功能的快速比较：

Uvicorn 和 Daphne 之间的选择取决于您的具体需求和优先级。请考虑以下因素：

• 性能：如果高性能是首要考虑因素，Uvicorn 可能是一个更好的选择，因为它具有轻量级的特性和优化的事件循环。

• WebSocket 与实时需求：两款服务器均支持 WebSocket 并支持服务器发送事件，非常适合实时应用。如果您有大量 WebSocket 需求，可以考虑 Daphne 与 Django Channels 的集成。

• 高级功能： Daphne 提供自动 WebSocket 协议升级和集成管理命令等附加功能，使其有利于复杂的 Django 应用程序。

• 兼容性： Uvicorn 更通用，可以与各种 Python 框架一起使用，而 Daphne 专门针对 Django 应用程序量身定制。

如果您需要高性能、简洁性以及与不同框架的兼容性，请选择 Uvicorn。如果您需要高级功能、增强的 WebSocket 支持以及与 Django 和 Django Channels 的无缝集成，请选择 Daphne。

Uvicorn 与 Gunicorn 搭配使用也是一个不错的选择，因为它为 Django 应用提供了强大的服务组合。Gunicorn 是一个可靠且广泛使用的 WSGI 服务器，而 Uvicorn 则具备 ASGI 支持和高性能事件驱动处理的优势。

通过将 Uvicorn 作为工作线程类集成到 Gunicorn，您可以充分利用 Gunicorn 的简洁性和稳定性，同时利用 Uvicorn 高效处理异步请求的能力。此设置允许您充分利用 Uvicorn 的快速事件循环实现、WebSocket 支持和其他 ASGI 功能，同时受益于 Gunicorn 的进程管理、负载均衡以及与各种部署场景的兼容性。

点击此处了解更多信息。

Uvicorn 和 Gunicorn 共同为具有同步和异步功能的 Django 应用程序提供了坚实的基础。

下面介绍了如何将 Uvicorn 合并到您现有的 Django 应用程序中：

1. 安装 Uvicorn：
   

   pip install uvicorn
   

2. 创建 ASGI 入口点文件：在项目的根目录中，创建一个名为的文件asgi.py并添加以下内容：
   

   import os
   from django.core.asgi import get_asgi_application
   
   os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'your_project_name.settings')
   application = get_asgi_application()
   

3. 测试 ASGI 服务器：现在，您可以通过在项目的根目录中运行以下命令，使用 Uvicorn 在本地测试 ASGI 服务器：
   

   uvicorn your_project_name.asgi:application
   

   Uvicorn 将启动 ASGI 服务器，它将使用 ASGI 入口点文件运行您的 Django 应用程序asgi.py。

4. 配置您的 Web 服务器：要将 Uvicorn 与您的 Web 服务器一起使用，您需要将其配置为将请求代理到 Uvicorn，然后 Uvicorn 将处理与您的 Django 应用程序的 ASGI 通信。

   如果您使用 Nginx，则可以在 Nginx 服务器块中添加代理配置，如下所示：
   

   location / {
       proxy_pass http://localhost:8000;
       proxy_set_header Host $host;
       proxy_set_header X-Real-IP $remote_addr;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
   }
   

5. 重新启动 Web 服务器：进行必要的配置更改后，重新启动 Web 服务器以应用更新。

在官方 Django 文档中阅读更多内容。

什么是 HTTPX？

HTTPX是一个流行的 Python 库，它提供了一个异步 HTTP 客户端，它对于在 Django 中启用异步支持非常有用。虽然 Django 本身不需要 HTTPX 来实现异步支持，但将 HTTPX 与 Django 的异步视图结合使用可以带来以下几个好处：

1. 异步功能： HTTPX 在设计时就充分考虑了异步支持，并提供了完全异步的 API 来发出 HTTP 请求。它与 Django 等异步框架无缝集成，允许您异步执行 HTTP 操作而不会阻塞事件循环，从而增强应用程序的响应能力和可扩展性。

2. 性能与效率： HTTPX 构建于支持异步的httpcore库之上，该库提供了高性能的 HTTP 客户端实现。通过利用 HTTPX 的异步功能，您可以利用异步 I/O 的非阻塞特性，高效地并发执行 HTTP 请求，从而降低延迟并提升应用程序的整体性能。

3. 灵活且现代化的功能： HTTPX 提供了一个现代化且功能丰富的 HTTP 客户端，支持请求流、自动处理重定向、身份验证、连接池等功能。它提供了用户友好的界面，并支持各种 HTTP 协议和方法，适用于广泛的用例。

4. 与异步生态系统的兼容性： HTTPX 与异步生态系统完美契合，并能与其他异步库和框架无缝集成。它可以轻松地与 Django 的异步视图、Django Channels 和其他异步组件一起使用，从而允许您在 Django 应用程序中构建端到端的异步工作流。

虽然 Django 通过模块提供了自己的同步 HTTP 客户端django.http.HttpClient，但它缺乏 HTTPX 的异步功能和性能优势。

因此，如果您正在使用异步视图或需要在 Django 应用程序中执行异步 HTTP 操作，那么集成 HTTPX 是一个有价值的选择，可以充分利用异步编程的强大功能并提高应用程序 HTTP 交互的效率和响应能力。

要在 Django 中使用 HTTPX，您可以按照以下步骤操作：

1. 安装 HTTPX：首先使用 pip 安装 HTTPX 库。打开终端或命令提示符并运行以下命令：
   

   pip install httpx
   

2. 导入 HTTPX 并发出 HTTP 请求：在您想要使用 HTTPX 的 Django 视图或其他组件中，从httpx模块导入必要的类和函数。

   导入 HTTPX 后，您现在可以使用它来发出 HTTP 请求。它提供了一个用于AsyncClient异步请求的客户端类。您可以创建它的实例AsyncClient并使用它来发出各种类型的请求。

   以下是向远程 API 发出 GET 请求的示例：
   

   import httpx
   
   async def my_async_view(request):
       try:
           response = await httpx.get('https://api.example.com/data')
           response.status_code = httpx.codes.OK
           data = response.json()
       except httpx.HTTPError as e:
           # Handle the HTTP error
           return HttpResponseServerError(str(e))
   
       # Process the data and return an HTTP response
       return HttpResponse(data)
   

现在，我们准备了解 Django 中不同组件的异步支持。

异步适配器函数

在 Django 中，async_to_sync和sync_to_async函数由 模块提供asgiref.sync。它们作为实用函数，用于弥合 Django 框架内同步代码和异步代码之间的差距。

1. async_to_sync：此函数允许你在异步上下文中调用同步代码。它接受一个异步可调用函数（协程）作为参数，并返回一个同步包装器。

   当您拥有想要在异步视图中使用的现有同步代码或需要从异步上下文调用同步 Django 函数时，这很有用。

   如果您需要从异步视图或异步函数调用同步 Django 函数（例如render()、get_object_or_404()或reverse()），则可以使用包装这些调用async_to_sync。

   例如：
   

from asgiref.sync import async_to_sync

async def async_function():
    # Some asynchronous code

sync_function = async_to_sync(async_function)
result = sync_function()

在上面的例子中，async_function是一个异步协程，但sync_function它是一个同步包装器。通过调用sync_function()，异步代码可以同步执行。

1. sync_to_async：此函数允许你在同步上下文中调用异步代码。它接受一个同步可调用函数作为参数，并返回一个异步包装器。当你需要在异步上下文中使用现有的同步代码，或者需要从同步 Django 代码中调用异步函数时，此功能非常有用。

例如：

from asgiref.sync import sync_to_async

def sync_function():
    # Some synchronous code

async_function = sync_to_async(sync_function)
result = await async_function()

在上面的例子中，sync_function是一个同步函数，但async_function它被一个异步包装器包裹着。通过使用await async_function()，同步代码可以异步执行。

Django中的函数sync_to_async()提供了两种线程模式，用于将同步函数转换为异步函数：

1. thread_sensitive=True（默认）：在此模式下，同步函数将与其他线程敏感函数在同一线程中运行。通常，如果同步函数使用了async_to_sync()包装器，则该线程将是主线程。

2. thread_sensitive=False：在此模式下，同步函数将在专门为调用而创建的新线程中运行。函数执行完成后，此线程将关闭。

Django 中这些模式的原因是为了与现有代码保持兼容性，这些代码假设所有内容都在同一线程中运行。某些库（尤其是数据库适配器）需要从创建它们的同一线程进行访问。此外，各种 Django 代码（例如中间件）会将信息添加到请求中以供将来在视图中使用，并假设所有操作都在同一线程中执行。

为了保证兼容性，Django引入了线程敏感模式，让现有的同步代码在同一个线程中运行，并且与异步模式保持完全兼容。

请记住，同步代码始终与调用它的异步代码在不同的线程中执行。因此，务必避免在它们之间传递原始数据库句柄或其他线程敏感的引用。

通过提供这些线程模式，sync_to_async()您可以在异步上下文中使用同步函数时控制其执行环境。

Django 中的异步视图

Django 3.1 中引入了异步视图功能，允许你使用async和await关键字将视图函数定义为异步协程。这使你可以在视图函数中编写非阻塞异步代码，从而更轻松地处理长时间运行的操作，在不阻塞事件循环的情况下执行 I/O 操作，并提高 Django 应用程序的整体响应能力和可扩展性。

异步视图可以与 Django 的请求/响应周期、URL 路由、中间件和其他功能一起使用。它们可以与现有的 Django 代码无缝集成，并且可以在同一应用程序中与传统的同步视图共存。

需要注意的是，异步视图并非适用于所有用例。它们在处理 I/O 密集型操作时最有效，这些操作可以从非阻塞执行中受益。对于 CPU 密集型任务，异步执行带来的性能提升有限，传统的同步视图可能仍然是更好的选择。

您可以使用async关键字 来定义异步视图函数。这允许将该函数定义为异步协程，并且在异步视图函数中，您可以使用await关键字 等待异步操作的完成，例如数据库查询、API 调用或其他异步函数。

这里有一个例子 -

import httpx
from django.http import JsonResponse

async def my_async_view(request):
    try:
        async with httpx.AsyncClient() as client:
            response = await client.get('https://api.example.com/data')
            response.raise_for_status()
            data = response.json()
    except httpx.HTTPError as e:
        # Handle the HTTP error
        return JsonResponse({'error': str(e)}, status=500)

    # Process the data and return an HTTP response
    return JsonResponse(data)

异步查询集

在 Django 中编写异步视图或代码时，需要注意的是，ORM 的使用方式与同步代码不同。在异步代码中调用阻塞式同步代码可能会导致事件循环阻塞。

因此，Django 提供了异步查询 API，允许您以异步方式执行查询。这些 API 提供了阻塞方法（例如get()和）的异步变体delete()，例如aget()和adelete()。此外，在迭代查询结果时，您可以使用异步迭代（async for）代替常规迭代（for）。

无需依靠反复试验来查找 ORM 方法的异步版本（例如，搜索“以 a 为前缀”的版本），这里有一个更系统的方法：

1. 返回新查询集的方法：这些方法不会阻塞，也没有明确的异步版本。

2. 不返回查询集的方法：这些方法会阻塞，但有相应的异步版本。每个方法的文档都会指定其对应的异步版本，通常以添加“a”前缀的方式进行。

例如，

user = await User.objects.filter(username='abc').afirst()

Django 中的该filter()方法返回一个查询集，使其适合在异步环境中进行链式调用。但是，该first()方法会计算并返回一个模型实例，这需要一种异步友好的方法。为了解决这个问题，我们将 替换first()为，并在表达式的开头afirst()添加关键字，以确保正确异步执行。await

通过利用这些异步查询 API，您可以在异步视图或代码中安全地执行数据库操作，确保无阻塞执行和高效利用系统资源。

然而，事务在异步模式下还无法工作。如果你有一段代码需要事务行为，你应该将其编写为一个同步函数，并使用sync_to_async()如下方式调用它：

async def async_view(request, ...):
    sync_to_async(sync_db_transaction)(...)

@transaction.atomic()
def sync_db_transaction(...):
    ....

Django 异步开发的最佳实践

当谈到 Django 中的异步开发时，您可以遵循一些最佳实践，以确保高效有效地处理异步任务：

1. 使用异步 Web 服务器： Django 主要与 Gunicorn 或 uWSGI 等同步 Web 服务器配合使用。但是，为了高效处理异步请求，建议使用 Daphne 或 Uvicorn 等异步 Web 服务器，它们可以更有效地利用 Django 的异步功能。

2. 选择合适的异步库： Django 通过使用异步视图和中间件支持异步编程。但是，您可能还需要使用外部异步库来处理特定任务。一些常用的选择包括 asyncio、aiohttp 和 httpx。请选择最符合您需求且能与 Django 异步功能良好集成的库。

3. 利用 Django 的异步功能： Django 在最新版本中引入了异步支持，允许您定义异步视图、中间件和数据库操作。请在适当的情况下利用这些功能来提升应用程序的性能。

4. 使用异步任务队列：对于长时间运行或资源密集型的任务，可以考虑将它们迁移到异步任务队列，例如Celery，它与 Django 集成良好。这允许您在后台异步处理任务，从而释放 Web 服务器的资源来处理更多传入请求。

5. 注意线程安全：使用异步编程时，确保线程安全至关重要。避免在异步任务之间共享未进行适当同步的可变对象。必要时使用线程安全的数据结构或锁定机制，以防止竞争条件。

6. 优化数据库查询：异步视图可以显著提升性能，但低效的数据库查询仍然会成为瓶颈。请务必通过使用适当的索引、最小化查询次数以及利用 Django 的 ORM 功能（例如select_related()和 ）来优化数据库查询，prefetch_related()以最大程度地减少数据库往返次数。

7. 监控并分析您的应用程序：异步编程可能会带来新的复杂性和潜在问题。监控并分析您的应用程序，以识别任何性能瓶颈、资源泄漏或意外行为。Django Debug Toolbar、Django Silk 等工具或专用的分析库可以帮助您识别和解决这些问题。

8. 编写全面的测试：异步代码的测试可能比同步代码更具挑战性。请确保编写涵盖应用程序同步和异步部分的全面测试。使用类似pytest-asyncio或 Django 内置测试实用程序的测试框架来编写和执行异步测试。

9. 保持代码库的可维护性：异步代码很快就会变得复杂，因此遵循良好的编码实践对于保持代码库的可维护性至关重要。请使用清晰易懂的变量和函数名称，遵循一致的编码约定，并记录所有异步代码接口和行为。

请记住，并非 Django 应用程序的所有部分都需要异步。请评估哪些用例和任务可以从异步处理中受益，并明智地应用它。此外，还需权衡异步编程的利弊，例如更高的复杂性和潜在的调试挑战。

结论

总而言之，通过 Django 的异步支持来提升性能，可以彻底改变你的 Web 应用程序。通过 Django 的异步支持，你可以将应用程序的性能提升到新的高度，提供更快的响应速度、处理更多并发请求，并提供无缝的用户体验。

然而，仔细评估应用程序的具体需求，并在异步编程能够带来最大益处的地方应用它至关重要。所以，深入探索 Django 的异步编程世界，释放应用程序的真正潜力吧。

请在下面的评论部分随意分享您的经验、挑战或积极成果。