Kemahiran pengoptimuman prestasi IO tak segerak dalam pembangunan web Python

Python, sebagai bahasa pengaturcaraan peringkat tinggi, telah menjadi salah satu pilihan arus perdana untuk pembangunan web. Walau bagaimanapun, dengan perkembangan pesat Internet, jumlah data dan keselarasan aplikasi web semakin tinggi dan lebih tinggi, yang menjadikan prestasi aplikasi web menjadi isu penting. Untuk memenuhi keperluan perniagaan dan pengalaman pengguna, teknik pengoptimuman prestasi IO tak segerak dalam pembangunan web Python semakin menjadi tempat tumpuan penyelidikan.

Pengenalan kepada IO tak segerak

IO tak segerak merujuk kepada menggunakan operasi IO tidak menyekat dalam satu utas dan menyerahkan operasi IO kepada sistem pengendalian untuk memproses berbilang permintaan IO dalam urutan yang sama. Tujuan. Dalam erti kata lain, pemprosesan IO tak segerak tidak memerlukan kaedah berbilang proses, berbilang benang dan pelbagai tugas lain.

Prinsip IO tak segerak

Dalam Python, IO tak segerak biasanya dilaksanakan melalui coroutine. Coroutine dipanggil benang ringan yang melaksanakan pelaksanaan bergantian berbilang tugas melalui penggantungan dan pemulihan. Dalam coroutine, kami boleh menggunakan pengoptimuman tak segerak bagi operasi IO untuk meningkatkan prestasi aplikasi web.

Bagi coroutine, ia adalah konsep yang sukar untuk difahami Berikut ialah contoh coroutine yang mudah:

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())

Seperti yang anda lihat, dalam contoh di atas, kami mencipta dua objek coroutine, Serahkan mereka. ke gelung acara untuk dilaksanakan. Gelung acara boleh dianggap sebagai penjadual pusat yang boleh mengawal urutan pelaksanaan dan penukaran coroutine.

Ciri terbesar coroutine dan IO tak segerak ialah ia boleh "menjeda" dan menunggu pada operasi IO, tunggu sehingga operasi IO mengembalikan hasilnya, dan kemudian "bangun" untuk terus melaksanakan kod berikutnya, jadi untuk mengelakkan program daripada terganggu semasa operasi IO berlaku, dengan itu meningkatkan prestasi program.

Petua IO tak segerak dalam pembangunan web Python

1. Gunakan rangka kerja tidak menyekat tak segerak: aiohttp

aiohttp ialah Python yang menyokong IO tak segerak Rangka kerja web yang menggunakan coroutine untuk melaksanakan operasi IO yang cekap dan mempunyai sokongan penuh untuk HTTP/1.1 dan WebSocket. Rangka kerja ini mudah dipelajari dan boleh membantu pembangun melaksanakan aplikasi IO tak segerak yang pantas.

Beberapa cara untuk menggunakannya:

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. Pengoptimuman tak segerak untuk tugas intensif IO

Operasi I/O untuk data tapak web cenderung kepada lebih CPU -intensif daripada Ia lebih memakan masa, jadi pengoptimuman tak segerak untuk tugas intensif IO boleh meningkatkan prestasi aplikasi web dengan ketara. Contohnya, kod sampel berikut:

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())

Dalam contoh di atas, kami menggunakan perpustakaan tak segerak Python aiohttp dan menggunakan coroutine untuk melaksanakan permintaan untuk 50 data JSON dalam urutan yang sama, dengan itu dalam masa yang singkat Capai cekap pelaksanaan serentak pelbagai tugas.

3. Gunakan pemacu pangkalan data tak segerak

Operasi pangkalan data selalunya merupakan salah satu kesesakan prestasi dalam aplikasi web Kami boleh menggunakan pemacu pangkalan data tak segerak yang disediakan dalam Python, seperti aiomysql, asyncpg, dsb., untuk mencapai operasi tak segerak pada pangkalan data, dengan itu meningkatkan prestasi aplikasi 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())

Kod di atas menunjukkan cara menggunakan perpustakaan aiomysql untuk melaksanakan operasi pangkalan data MySQL tak segerak Memandangkan operasi pangkalan data biasanya sangat perlahan, kami biasanya menggunakan struktur sintaks async with untuk melengkapkan kawalan coroutine kod perlu dilaksanakan Operasi pangkalan data berbilang, kemudian kita boleh menggunakan pengumpulan sambungan dan kaedah lain untuk meningkatkan prestasi operasi MySQL.

Ringkasan

IO tak segerak dalam Python boleh dikatakan sebagai kelebihan utama dalam pembangunan web dan boleh membantu kami melaksanakan aplikasi web yang cekap dengan cepat. Semasa proses pembangunan, kami boleh menggunakan rangka kerja tidak menyekat tak segerak, pengoptimuman serentak untuk tugas intensif IO dan pemacu pangkalan data tak segerak untuk meningkatkan prestasi aplikasi web.

Atas ialah kandungan terperinci Kemahiran pengoptimuman prestasi IO tak segerak dalam pembangunan web Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!