Compétences en optimisation des performances des E/S asynchrones dans le développement Web Python

Python, en tant que langage de programmation de haut niveau, est devenu l'un des choix courants pour le développement Web. Cependant, avec le développement rapide d'Internet, le volume de données et la concurrence des applications Web sont de plus en plus élevés, ce qui fait que les performances des applications Web deviennent un problème important. Afin de répondre aux besoins des entreprises et à l'expérience utilisateur, les techniques d'optimisation des performances d'E/S asynchrones dans le développement Web Python sont de plus en plus devenues un point chaud de la recherche.

Introduction aux IO asynchrones

Les IO asynchrones font référence à l'utilisation d'opérations IO non bloquantes dans un seul thread et au fait de laisser les opérations IO au système d'exploitation pour atteindre l'objectif de traiter plusieurs requêtes IO dans le même thread. En d'autres termes, le traitement des E/S asynchrones ne nécessite pas de méthodes multi-processus, multi-thread et autres méthodes multitâches.

Principe des IO asynchrones

En Python, les IO asynchrones sont généralement implémentées via des coroutines. Coroutine est appelé un thread léger qui réalise l'exécution alternative de plusieurs tâches en suspendant et en reprenant. Dans les coroutines, nous pouvons utiliser l'optimisation asynchrone des opérations d'E/S pour améliorer les performances des applications Web.

Quant aux coroutines, c'est un concept difficile à comprendre. Voici un exemple de coroutine simple :

import asyncio

async def my_coroutine():
    print('开始执行协程...')
    await asyncio.sleep(1)
    print('协程执行完毕 !')
    
async def main():
    # 第一个协程
    coro1 = my_coroutine()
    # 第二个协程
    coro2 = my_coroutine()
    print("开始执行两个协程...")
    await coro1
    await coro2

# 实例化一个事件循环
loop = asyncio.get_event_loop()
# 执行主协程
loop.run_until_complete(main())

Comme vous pouvez le voir, dans l'exemple ci-dessus, nous avons créé deux objets coroutine et les avons remis à la boucle d'événements pour exécution . La boucle d'événements peut être considérée comme un planificateur central capable de contrôler la séquence d'exécution et la commutation des coroutines.

La plus grande caractéristique des coroutines et des IO asynchrones est qu'elles peuvent « faire une pause » et attendre l'opération IO, attendre que l'opération IO renvoie le résultat, puis « se réveiller » pour continuer à exécuter le code suivant. Cela peut éviter le programme. du blocage pendant l'opération IO, améliorant ainsi les performances du programme.

Compétences IO asynchrones dans le développement Web Python

1. Utilisez un framework asynchrone non bloquant : aiohttp

aiohttp

aiohttp 是一个支持异步IO的Python web框架，它使用协程实现高效的IO操作，并且能够对HTTP/1.1和WebSocket进行全面的支持。这个框架简单易学，能够帮助开发者实现快速的异步IO应用。

一些使用方式：

from aiohttp import web

async def handle(request):
    # 获取get参数，即 ?name=test
    name = request.query.get('name', "Anonymous")
    text = "Hello, " + name
    # 返回Response对象
    return web.Response(text=text)

# 初始化web应用，创建一个app对象
app = web.Application()
# 把URL路径'/'和函数句柄handle绑定到一起
app.add_routes([web.get('/', handle)])

# 启动web应用服务
if __name__ == '__main__':
    web.run_app(app, port=8080)

2. 对IO密集型任务进行异步优化

网站数据的I/O操作往往比CPU密集型操作更为耗时，因此针对IO密集型任务进行异步优化，能够较为显著地提升web应用的性能表现。如下面的示例代码：

import aiohttp
import asyncio

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def main():
    async with aiohttp.ClientSession() as session:
        tasks = []
        for i in range(50):
            task = asyncio.create_task(fetch(session, f'https://jsonplaceholder.typicode.com/todos/{i}'))
            tasks.append(task)

        responses = await asyncio.gather(*tasks)
        # do something with responses...

# 实例化一个事件循环
loop = asyncio.get_event_loop()
# 执行异步任务
loop.run_until_complete(main())

上述示例中我们使用了Python的异步库aiohttp，使用了协程实现了在同一线程中对50个JSON数据进行请求，从而在短时间内实现了高效率地多任务并发执行。

3. 使用异步数据库驱动

数据库操作往往也是web应用中性能瓶颈之一，我们可以使用Python中提供的异步数据库驱动，如aiomysql、asyncpg等，实现对数据库的异步操作，从而提升web应用的性能表现。

import asyncio
import aiomysql

async def test_example():
    async with aiomysql.create_pool(host='localhost', user='root',
                                    password='', db='test', charset='utf8mb4',
                                    autocommit=True) as pool:
           async with pool.acquire() as conn:
               async with conn.cursor() as cur:
                    await cur.execute("select id, name from tb_user where id=1")
                    result = await cur.fetchone()
                    print(result)

if __name__ == '__main__':
    # 实例化一个事件循环
    loop = asyncio.get_event_loop()
    # 执行异步任务
    loop.run_until_complete(test_example())

上述代码展示了如何使用aiomysql库进行异步的MySQL数据库操作，由于数据库操作通常很慢，我们通常使用async withaiohttp est un Python qui prend en charge asynchronous IO Un framework Web qui utilise des coroutines pour implémenter des opérations d'E/S efficaces et prend entièrement en charge HTTP/1.1 et WebSocket. Ce framework est facile à apprendre et peut aider les développeurs à mettre en œuvre des applications IO asynchrones rapides.

Quelques façons de l'utiliser :

rrreee

Optimisation asynchrone des tâches gourmandes en E/S

Les opérations d'E/S pour les données de sites Web sont souvent plus coûteuses que celles gourmandes en CPU temps d'opération, donc l'optimisation asynchrone pour les tâches gourmandes en E/S peut améliorer considérablement les performances des applications Web. Par exemple, l'exemple de code suivant : 🎜rrreee🎜Dans l'exemple ci-dessus, nous avons utilisé la bibliothèque asynchrone de Python aiohttp et utilisé des coroutines pour implémenter des requêtes pour 50 données JSON dans le même thread, donc en peu de temps Efficace l'exécution simultanée de plusieurs tâches est réalisée au sein du système. 🎜

🎜Utiliser un pilote de base de données asynchrone

🎜Les opérations de base de données sont souvent l'un des goulots d'étranglement des performances dans les applications Web. Nous pouvons utiliser le pilote de base de données asynchrone fourni dans Python, tel que <. code> aiomysql, asyncpg, etc., réalisent des opérations asynchrones sur la base de données, améliorant ainsi les performances des applications Web. 🎜rrreee🎜Le code ci-dessus montre comment utiliser la bibliothèque aiomysql pour effectuer des opérations de base de données MySQL asynchrones étant donné que les opérations de base de données sont généralement très lentes, nous utilisons généralement la structure syntaxique async with. pour compléter les coroutines Contrôle ; si le code doit effectuer plusieurs opérations de base de données, nous pouvons alors utiliser le regroupement de connexions et d'autres méthodes pour améliorer les performances des opérations MySQL. 🎜🎜Résumé🎜🎜Les E/S asynchrones en Python peuvent être considérées comme un avantage majeur dans le développement Web et peuvent nous aider à mettre en œuvre rapidement des applications Web efficaces. Pendant le processus de développement, nous pouvons utiliser des frameworks asynchrones non bloquants, une optimisation de la concurrence pour les tâches gourmandes en E/S et des pilotes de base de données asynchrones pour améliorer les performances des applications Web. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!