Pengaturcaraan pelayan Python: Pengenalan kepada modul konkurensi terbina dalam Python

Pengaturcaraan pelayan Python: Pengenalan kepada modul konkurensi terbina dalam Python

Dengan populariti Internet dan peranti mudah alih, aplikasi rangkaian semakin memerlukan program pelayan berprestasi tinggi. Sebagai bahasa pengaturcaraan yang cekap dan berskala, Python memainkan peranan yang semakin penting dalam pengaturcaraan rangkaian. Artikel ini akan menumpukan pada memperkenalkan modul konkurensi terbina dalam Python untuk membantu pembaca lebih memahami mekanisme konkurensi dalam pengaturcaraan pelayan Python.

1. Benang

Python mempunyai modul benang terbina dalam, yang menyediakan sokongan untuk pengaturcaraan berbilang benang. Dengan mencipta benang, berbilang tugas boleh dilaksanakan serentak dalam program. Kod berikut menunjukkan cara menggunakan modul belitan untuk mencipta dan memulakan utas:

import threading

def worker(num):
    """线程执行的函数"""
    print('Worker %d is starting...' % num)

threads = []
for i in range(5):
    t = threading.Thread(target=worker, args=(i,))
    threads.append(t)
    t.start()

for t in threads:
    t.join()

Dalam kod di atas, 5 utas dicipta dengan memanggil fungsi threading.Thread() dan fungsi pelaksanaan setiap thread ialah ditetapkan sebagai pekerja (). Akhir sekali, mulakan utas ini dengan memanggil kaedah start() dan kemudian panggil kaedah join() untuk menunggu utas menyelesaikan pelaksanaan.

Perlu diambil perhatian bahawa benang dalam Python dilaksanakan berdasarkan urutan asli sistem pengendalian (iaitu, model benang satu-ke-satu). Pada sesetengah sistem pengendalian, benang boleh menggunakan sejumlah besar sumber sistem, walaupun semasa melahu. Oleh itu, apabila menggunakan benang, bilangan benang harus digunakan secara munasabah mengikut situasi tertentu untuk mengelakkan pembaziran sumber.

2. Proses

Python mempunyai modul berbilang pemprosesan terbina dalam, yang menyediakan sokongan untuk konkurensi dan komunikasi antara proses. Dengan menggunakan modul berbilang pemprosesan, anda boleh melaksanakan berbilang proses serentak dalam program untuk menggunakan prestasi CPU berbilang teras dengan lebih baik. Kod berikut menunjukkan cara menggunakan modul multiprocessing untuk mencipta dan memulakan proses:

import multiprocessing

def worker(num):
    """进程执行的函数"""
    print('Worker %d is starting...' % num)

processes = []
for i in range(5):
    p = multiprocessing.Process(target=worker, args=(i,))
    processes.append(p)
    p.start()

for p in processes:
    p.join()

Dalam kod di atas, 5 proses dicipta dengan memanggil fungsi multiprocessing.Process() dan fungsi pelaksanaan setiap proses ditetapkan sebagai pekerja (). Akhir sekali, mulakan proses ini dengan memanggil kaedah start() dan kemudian panggil kaedah join() untuk menunggu proses menyelesaikan pelaksanaan.

Perlu diingat bahawa komunikasi antara proses perlu dilaksanakan menggunakan Queue, Pipe dan kaedah lain, yang boleh didapati dalam modul multiprocessing.

3. Coroutine

Coroutine ialah mekanisme konkurensi ringan yang boleh melaksanakan pelaksanaan penukaran berbilang subprogram dalam satu proses. Python mempunyai modul asyncio terbina dalam, yang menyediakan sokongan untuk konkurensi coroutine. Dengan menggunakan modul asyncio, IO asynchronous dan pengaturcaraan rangkaian yang cekap boleh dicapai. Kod berikut menunjukkan cara menggunakan modul asyncio untuk melaksanakan coroutine:

import asyncio

async def worker(num):
    """协程执行的函数"""
    print('Worker %d is starting...' % num)
    await asyncio.sleep(1)
    print('Worker %d is finished.' % num)

async def main():
    """协程调度器"""
    tasks = [asyncio.create_task(worker(i)) for i in range(5)]
    await asyncio.gather(*tasks)

asyncio.run(main())

Dalam kod di atas, async digunakan untuk mentakrifkan worker fungsi coroutine(), dan async digunakan untuk menentukan penjadual coroutine main() . Cipta 5 tugas coroutine melalui fungsi asyncio.create_task() dan gunakan fungsi asyncio.gather() untuk pelaksanaan serentak. Akhir sekali, penjadual coroutine dijalankan melalui fungsi asyncio.run().

Perlu diingatkan bahawa program coroutine sangat fleksibel dan cekap, tetapi memerlukan keupayaan pengaturcaraan yang tinggi dan pengetahuan profesional.

4. Ringkasan

Tiga modul konkurensi terbina dalam Python (benang, pemproses berbilang, asyncio) boleh menyediakan mekanisme konkurensi yang berbeza dalam senario yang berbeza. Semasa menulis program pelayan, anda perlu memilih modul konkurensi yang sesuai dan mekanisme konkurensi berdasarkan keperluan sebenar untuk meningkatkan prestasi dan kebolehpercayaan program.

Perlu diperhatikan bahawa Python bukanlah bahasa pengaturcaraan pelayan khusus, jadi apabila menulis program pelayan berprestasi tinggi, faktor lain perlu dipertimbangkan, seperti bilangan sambungan, konkurensi, masa respons permintaan, dsb. . Dengan memilih modul konkurensi secara rasional dan mereka bentuk algoritma yang berkesan, prestasi program pelayan boleh dioptimumkan dan pengalaman pengguna yang baik boleh disediakan.

Atas ialah kandungan terperinci Pengaturcaraan pelayan Python: Pengenalan kepada modul konkurensi terbina dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!