Barisan kematian GIL: Melanggar had serentak dan membebaskan Python

Putuskan belenggukunci python

GIL Kunci Jurubahasa Global (GIL)

Python ialah mekanisme perlindungan yang menghalang berbilang benang daripada melaksanakan kod bait secara serentak. Walaupun ia memastikan benangkeselamatan jurubahasa Python, ia melakukannya dengan mengorbankan konkurensi, terutamanya dalam tugas intensif CPU.

Untuk memintas sekatan GIL, anda mempunyai beberapa pilihan:

Berbilang benang

Multi-threading membolehkan penciptaan benang selari dalam satu proses Python. Walaupun GIL masih menghalang utas daripada melaksanakan kod bait Python secara serentak, mereka boleh melaksanakan operasi I/O, menjalankan sambungan C atau melaksanakan kod asli secara serentak.

Kod demo:

import threading

def io_bound_task():
with open("large_file.txt", "r") as f:
data = f.read()

def cpu_bound_task():
for i in range(1000000):
i * i

threads = []
threads.append(threading.Thread(target=io_bound_task))
threads.append(threading.Thread(target=cpu_bound_task))

for thread in threads:
thread.start()

for thread in threads:
thread.join()

Dalam contoh ini, io_bound_task 是 I/O 密集型的，cpu_bound_task adalah intensif CPU. Memandangkan GIL tidak menyekat operasi I/O, dua utas boleh dilaksanakan secara serentak.

Proses

Tidak seperti benang, proses ialah sistem pengendalianentiti serentak peringkat. Mereka mempunyai ruang memori mereka sendiri dan sumber sistem pengendalian dan oleh itu tidak dihadkan oleh GIL.

Kod demo:

import multiprocessing

def cpu_bound_task(n):
for i in range(1000000):
i * i

if __name__ == "__main__":
processes = []
for i in range(4):
processes.append(multiprocessing.Process(target=cpu_bound_task, args=(i,)))

for process in processes:
process.start()

for process in processes:
process.join()

Dalam contoh ini, kami mencipta 4 proses, setiap satu menjalankan tugas intensif CPU. Oleh kerana GIL dihadkan kepada satu proses, tugasan ini boleh dilaksanakan secara selari.

AsynchronousPengaturcaraan

Pengaturcaraan tak segerak ialah paradigma pengaturcaraan tidak menyekat yang membolehkan peristiwa dicetuskan tanpa menunggu keputusan. Ia menggunakan teknik seperti gelung acara dan panggil balik, membenarkan berbilang tugasan dilaksanakan secara selari, walaupun mereka mempunyai kunci GIL.

Kod demo:

import asyncio

async def io_bound_task():
reader, writer = await asyncio.open_connection("example.com", 80)
writer.write(b"GET / Http/1.1

")
data = await reader.read(1024)
print(data.decode())

async def main():
await asyncio.gather(io_bound_task(), io_bound_task())

asyncio.run(main())

Dalam contoh ini, kami menggunakan perpustakaan asyncio untuk melaksanakan dua tugas intensif I/O. Memandangkan asyncio menggunakan gelung peristiwa, tugasan ini boleh dilaksanakan serentak, walaupun ia mempunyai kunci GIL.

Kesimpulan

Dengan memanfaatkan berbilang benang, proses dan teknik pengaturcaraan tak segerak, kami boleh memecahkan batasan GIL dan melepaskan potensi serentak Python. Ini penting untuk meningkatkan prestasi pada tugas intensif CPU dan meningkatkan kebolehskalaan aplikasi besar. Memilih pendekatan terbaik bergantung pada keperluan khusus aplikasi anda dan sumber yang tersedia.

Atas ialah kandungan terperinci Barisan kematian GIL: Melanggar had serentak dan membebaskan Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!