Penjelasan terperinci tentang coroutine dalam Python

Python ialah bahasa pengaturcaraan popular yang digunakan secara meluas kerana kesederhanaan, kemudahan pembelajaran dan pelbagai aplikasi. Antaranya, coroutine adalah konsep yang sangat penting dalam Python dan salah satu asas pengaturcaraan IO tak segerak dalam Python. Artikel ini akan memberikan penjelasan terperinci tentang coroutine dalam Python.

1. Apakah coroutine?

Coroutine ialah benang ringan mod pengguna yang lebih mudah alih daripada benang sistem pengendalian. Ia dilaksanakan oleh pengaturcara dalam program, jadi tiada overhed penukaran konteks diselesaikan oleh program itu sendiri tanpa campur tangan luar Ia juga boleh mengurangkan penciptaan benang dan menggunakan sumber CPU dengan lebih cekap.

Ciri coroutine:

1. boleh dijalankan serentak dalam urutan yang sama, dan overhed pensuisan adalah sangat kecil, jadi ia menyokong konkurensi yang tinggi.
2. Status coroutine diuruskan oleh pengaturcara sendiri, yang lebih ringan daripada benang.

2. Pelaksanaan coroutine

Terdapat tiga cara untuk melaksanakan coroutine dalam Python: penjana, async/menunggu dan digabungkan dengan gevent. Di bawah ini kami perkenalkan satu persatu.

1. Penjana

Penjana dalam Python itu sendiri mempunyai fungsi penjimatan dan pemulihan keadaan, yang sangat sesuai untuk melaksanakan coroutine. Ciri terbesar coroutine penjana ialah menggunakan pernyataan hasil untuk menggantung fungsi dan menyimpan keadaan fungsi.

Berikut ialah contoh coroutine:

def simple_coroutine():
    print('-> coroutine started')
    x = yield
    print('-> coroutine received:', x)

# 调用协程
my_coroutine = simple_coroutine()
print(my_coroutine)  # <generator object simple_coroutine at 0x7f6b25c43eb0>

# 先启动协程，让协程处于暂停状态。
next(my_coroutine)  # -> coroutine started

# 发送消息给协程，它会恢复执行，并打印出消息
my_coroutine.send('hello world')  # -> coroutine received: hello world

Dalam contoh ini, fungsi simple_coroutine mengandungi ungkapan hasil, iaitu bendera coroutine penjana, apabila fungsi dipanggil , yang mengembalikan objek penjana. Program ini memajukan penjana kepada pernyataan hasil pertama dengan memanggil kaedah seterusnya() dan mencetak mesej "-> coroutine bermula". Kemudian, kami menghantar mesej "hello world" kepada penjana, yang telah ditangkap dalam pembolehubah x dan dicetak "-> coroutine received: hello world".

2. async/wait

Selepas Python 3.5, Python menyediakan sintaks asli async/wait yang menyokong coroutine. Ia menyediakan sintaks yang lebih bersih dan kebolehbacaan yang lebih baik.

Berikut ialah contoh async/wait:

import asyncio

async def countdown(n):
    while n > 0:
        print(f'T-minus {n}')
        await asyncio.sleep(1.0)
        n -= 1

asyncio.run(countdown(3))

Dalam contoh ini, async/wait membenarkan kami menggunakan kata kunci async dalam fungsi untuk mentakrif coroutine dan gunakan await untuk menggantung coroutine. Sudah tentu, untuk menggunakan sintaks async/menunggu, kita perlu menggunakan perpustakaan asyncio.

3. Digunakan bersama gevent

gevent ialah perpustakaan rangkaian Python berdasarkan coroutine Ia menyediakan model pengaturcaraan berasaskan hasil yang membolehkan pengaturcara menulis secara tak segerak, bukan-. Kod sekatan adalah mudah untuk ditulis dan diuji. Untuk menggunakan gevent, kita perlu memasangnya melalui pip terlebih dahulu.

Berikut ialah contoh menggunakan gevent:

import gevent

def task(pid):
    """
    函数中的sleep模拟阻塞一段时间，通过gevent中的异步框架进行并发。
    """
    gevent.sleep(0.5)
    print(f'Task {pid} done')

def synchronous():
    """
    任务同步执行
    """
    for i in range(1, 10):
        task(i)

def asynchronous():
    """
    任务异步执行
    """
    threads = [gevent.spawn(task, i) for i in range(10)]
    gevent.joinall(threads)

print('Synchronous:')
synchronous()

print('Asynchronous:')
asynchronous()

Dalam contoh ini, kami menggunakan rangka kerja gevent untuk melaksanakan coroutine tak segerak. Melalui contoh ini, kita dapat melihat dengan jelas bahawa semasa pelaksanaan tak segerak, tugasan dilakukan secara bergilir-gilir, mengambil kesempatan daripada ciri tak segerak coroutine. Semasa pelaksanaan segerak, kita dapat melihat bahawa tugasan dilaksanakan satu demi satu.

3. Kelebihan dan Kekurangan Coroutine

Kelebihan:

1. Coroutines adalah satu-benang secara lalai, yang mengelakkan overhed yang disebabkan oleh penukaran berbilang benang dan bertambah baik kecekapan.
2. Coroutines boleh mengelakkan masalah GIL (Global Interpreter Lock) pelbagai proses dan meningkatkan kecekapan program.
3. Coroutine boleh dibuat tanpa had, tetapi bilangan utas dan proses adalah terhad, tetapi membuka terlalu banyak coroutine juga akan menyebabkan masalah prestasi.

Kelemahan:

1. Coroutine adalah istimewa dan memerlukan pengaturcara untuk mengawal status berjalan program secara manual Kerumitannya agak tinggi dan memerlukan lebih banyak usaha.
2. Kod coroutine itu sendiri tidak mempunyai mekanisme pengendalian ralat, menjadikannya lebih sukar untuk mengendalikan pengecualian dan nyahpepijat kod.

4. Ringkasan

Artikel ini memperkenalkan secara terperinci konsep, kaedah pelaksanaan serta kelebihan dan kekurangan coroutine dalam Python. Coroutine ialah konsep yang sangat penting dalam Python dan salah satu asas pengaturcaraan IO tak segerak. Melalui coroutine, kami boleh menjalankan perniagaan secara serentak dalam urutan yang sama, meningkatkan kecekapan pelaksanaan program, mengelakkan banyak overhed penukaran konteks dan sangat menjimatkan sumber sistem. Walau bagaimanapun, coroutine juga mempunyai beberapa kelemahan, seperti keperluan tinggi pada kemahiran pengaturcaraan pengaturcara dan mekanisme pengendalian ralat yang tidak sempurna Masalah ini memerlukan pengaturcara untuk memberi perhatian apabila menggunakan coroutine.

Atas ialah kandungan terperinci Penjelasan terperinci tentang coroutine dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!