Pengaturcaraan pelayan Python: analisis kes pelaksanaan pengaturcaraan tak segerak

Sebagai bahasa pengaturcaraan yang cekap dan mudah dipelajari, Python telah menarik lebih banyak perhatian dalam bidang pengaturcaraan sebelah pelayan sejak beberapa tahun kebelakangan ini. Dengan pertumbuhan pesat trafik aplikasi Internet, pelayan mesti mempunyai konkurensi tinggi dan prestasi tinggi, dan pengaturcaraan tak segerak merupakan salah satu teknologi utama untuk mencapai matlamat ini. Artikel ini akan menggunakan analisis kes untuk membincangkan kaedah pelaksanaan dan penyelesaian pengoptimuman pengaturcaraan tak segerak bahagian pelayan Python, dan memberikan bantuan dan rujukan tertentu untuk pembangun yang sedang atau akan terlibat dalam pengaturcaraan pelayan Python.

1. Apakah itu pengaturcaraan tak segerak?

Pengaturcaraan tak segerak ialah model pengaturcaraan yang idea terasnya adalah untuk mencapai konkurensi tinggi dan aplikasi rangkaian berprestasi tinggi melalui operasi IO yang tidak menyekat dan mekanisme dipacu peristiwa. Berbeza daripada model pengaturcaraan segerak tradisional, pengaturcaraan tak segerak tidak menyekat dalam satu utas menunggu untuk selesainya operasi IO, sebaliknya menyerahkan operasi IO kepada gelung peristiwa IO untuk diproses. Apabila operasi IO selesai, gelung peristiwa akan memberitahu pelaksanaan fungsi panggil balik yang sepadan untuk memproses keputusan. Dengan cara ini, program boleh melaksanakan tugas lain sementara menunggu operasi IO selesai, sekali gus meningkatkan kecekapan keseluruhan aplikasi.

Python menyediakan pelbagai rangka kerja pengaturcaraan tak segerak, termasuk asyncio dan Tornado, dsb. Di sini kami akan menggunakan asyncio sebagai contoh untuk memperkenalkan penyelesaian pelaksanaan dan pengoptimuman pengaturcaraan tak segerak sisi pelayan Python.

2. Analisis Kes

Di bawah ini kita akan menggunakan kes yang mudah tetapi praktikal untuk menggambarkan proses pelaksanaan dan langkah berjaga-jaga pengaturcaraan tak segerak sebelah pelayan Python. Kes ini ialah pelayan HTTP yang mampu mengendalikan permintaan HTTP daripada pelanggan dan mengembalikan respons HTTP yang sepadan.

1. Pasang perpustakaan bergantung

Mula-mula pasang perpustakaan bergantung asyncio dan aiohttp.

pip install asyncio aiohttp

2. Menulis Pelayan HTTP

Berikut ialah kod pelayan HTTP yang lengkap. Di sini kami menggunakan perpustakaan asyncio terbina dalam Python dan pustaka aiohttp pihak ketiga untuk melaksanakan pelayan HTTP tak segerak. Pelayan boleh menggunakan coroutine semasa memproses permintaan HTTP, dengan itu mencapai keselarasan tinggi.

import asyncio
from aiohttp import web

async def handle(request):
    name = request.match_info.get('name', "Anonymous")
    text = "Hello, " + name
    return web.Response(text=text)

async def init(loop):
    app = web.Application(loop=loop)
    app.router.add_route('GET', '/{name}', handle)
    srv = await loop.create_server(app.make_handler(), '0.0.0.0', 8080)
    print('Server started at http://0.0.0.0:8080...')
    return srv

loop = asyncio.get_event_loop()
loop.run_until_complete(init(loop))
loop.run_forever()

Dalam kod di atas, kami mentakrifkan pemegang fungsi pemprosesan tak segerak, yang boleh menerima permintaan HTTP dan mengembalikan respons HTTP. Respons HTTP yang dikembalikan oleh fungsi pemegang mengandungi mesej alu-aluan dan nama pelanggan. Berbeza daripada pelayan HTTP segerak tradisional, kami menggunakan coroutine yang disediakan oleh perpustakaan asyncio untuk mengendalikan permintaan HTTP, dengan itu mencapai keselarasan tinggi dan prestasi tinggi.

Kami mencipta apl aplikasi web tak segerak menggunakan web.Pembina aplikasi daripada perpustakaan aiohttp. Kemudian kami mengaitkan laluan '/{name}' dengan fungsi pemegang.

Akhir sekali, kami menggunakan fungsi init mekanisme gelung peristiwa yang disediakan oleh perpustakaan asyncio untuk mendaftarkan aplikasi ke dalam gelung acara dan memulakan perkhidmatan HTTP pada port 8080 tempatan. Ambil perhatian bahawa fungsi create_server asynchronous yang diperkenalkan dalam Python 3.7 digunakan untuk mencipta pelayan.

3. Pelaksanaan klien HTTP tak segerak

Dalam pengaturcaraan tak segerak, pelayan bukanlah satu-satunya tempat di mana I/O tak segerak perlu dirujuk. Sama seperti apabila kami menggunakan klien HTTP tak segerak, pelanggan juga boleh menggunakan coroutine untuk mengendalikan I/O.

Berikut ialah kod lengkap untuk mendapatkan data daripada pelayan menggunakan klien HTTP tak segerak.

import asyncio
import aiohttp

async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get('http://localhost:8080/yingyonghu') as response:
            print(await response.text())

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Dalam kod di atas, kami menggunakan klien HTTP tak segerak untuk mendapatkan data daripada pelayan HTTP dan bukannya menggunakan klien HTTP segerak tradisional. Perbezaan utama ialah kami menggunakan async dengan pernyataan dan bukannya normal dengan pernyataan. Ini memastikan bahawa klien HTTP tak segerak ditutup secara automatik apabila panggilan tak segerak selesai atau pengecualian berlaku. Dalam contoh ini, kami menggunakan kelas ClientSession pustaka aiohttp untuk mencipta sesi klien HTTP secara tak segerak, dan kemudian menggunakan kaedah get untuk mendapatkan data yang dikembalikan oleh pelayan secara tidak segerak.

Akhir sekali, kami menggunakan fungsi utama mekanisme gelung peristiwa yang disediakan oleh pustaka asyncio untuk mendaftarkan kod tak segerak ke dalam gelung peristiwa dan melaksanakan gelung peristiwa.

4. Penyelesaian pengoptimuman

Walaupun pengaturcaraan tak segerak boleh mencapai konkurensi tinggi dan prestasi tinggi, ia juga membawa beberapa cabaran dan pertimbangan pengoptimuman. Di bawah ialah beberapa pengoptimuman yang boleh anda gunakan untuk meningkatkan prestasi pelayan Python tak segerak anda.

(1) Gunakan kumpulan benang untuk pengiraan intensif CPU

Pengaturcaraan tak segerak biasanya digunakan untuk mengendalikan kerja intensif I/O. Walau bagaimanapun, jika aplikasi anda perlu melakukan pengiraan intensif CPU, pengaturcaraan tak segerak bukanlah penyelesaian yang optimum. Walaupun ada kemungkinan untuk menggunakan multi-threading untuk melaksanakan pengaturcaraan tak segerak, ini akan mengurangkan prestasi. Oleh itu, kami boleh menggunakan kumpulan benang untuk mengoptimumkan prestasi aplikasi kami, dengan itu meningkatkan prestasi apabila melakukan pengiraan intensif CPU.

(2) Kurangkan penggunaan menyekat operasi IO

Menyekat operasi IO adalah had pengaturcaraan tak segerak kerana ia akan mengurangkan keselarasan keseluruhan aplikasi. Oleh itu, kita harus meminimumkan penggunaan menyekat operasi IO supaya aplikasi boleh bertindak balas kepada permintaan dengan lebih cepat.

(3) Gunakan pengehad concurrency mengikut keperluan

Penghad concurrency boleh mengawal bilangan permintaan yang diproses secara serentak. Jika aplikasi anda mengendalikan sejumlah besar permintaan secara serentak, isu prestasi mungkin berlaku. Oleh itu, adalah lebih baik untuk membolehkan pengehad konkurensi atas permintaan mengawal bilangan permintaan serentak apabila diperlukan.

3. Ringkasan

Model pengaturcaraan tak segerak Python boleh membantu pembangun dengan mudah melaksanakan aplikasi rangkaian berkonkurensi tinggi dan berprestasi tinggi. Dalam artikel ini, kami mengambil pelayan HTTP sebagai contoh untuk memperkenalkan kaedah asas dan langkah berjaga-jaga pengaturcaraan tak segerak Python, dan menyediakan beberapa penyelesaian pengoptimuman untuk membantu meningkatkan prestasi aplikasi. Ringkasnya, model pengaturcaraan tak segerak ialah alat yang sangat berkuasa dalam pengaturcaraan bahagian pelayan Python dan boleh membantu pembangun membina aplikasi web yang lebih cekap, boleh dipercayai dan berskala.

Atas ialah kandungan terperinci Pengaturcaraan pelayan Python: analisis kes pelaksanaan pengaturcaraan tak segerak. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!