Python Academy · Pelajaran

ThreadPoolExecutor

Jalankan tugasan serentak

Pelajaran 2 daripada 413 langkah

ThreadPoolExecutor ialah pelajaran Python Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Python Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Mengapa Kumpulan Utas?

Mencipta dan menyertai utas secara manual memenatkan. concurrent.futures.ThreadPoolExecutor mengurus kumpulan utas pekerja untuk Anda dan mengembalikan hasil dengan kemas.

from concurrent.futures import ThreadPoolExecutor

def square(n):
    return n * n

with ThreadPoolExecutor() as ex:
    future = ex.submit(square, 5)
    print(future.result())

submit dan Future

submit() menjadualkan panggilan dan mengembalikan Future dengan serta-merta. Anda memanggil .result() padanya untuk mendapatkan nilai, dan panggilan itu akan menyekat sehingga nilai tersebut tersedia.

from concurrent.futures import ThreadPoolExecutor

def greet(name):
    return 'hi ' + name

with ThreadPoolExecutor(max_workers=2) as ex:
    f1 = ex.submit(greet, 'Ana')
    f2 = ex.submit(greet, 'Bob')
    print(f1.result())
    print(f2.result())

map untuk Banyak Input

executor.map(func, iterable) menjalankan fungsi pada setiap item secara serentak dan menghasilkan hasil mengikut susunan input.

from concurrent.futures import ThreadPoolExecutor

def cube(n):
    return n ** 3

with ThreadPoolExecutor() as ex:
    results = ex.map(cube, range(5))
    print(list(results))

Mengawal Bilangan Pekerja

max_workers mengehadkan bilangan utas yang berjalan pada satu-satu masa. Untuk kerja terikat input/output, Anda boleh menggunakan lebih banyak pekerja daripada bilangan teras CPU.

from concurrent.futures import ThreadPoolExecutor
import time

def io_task(n):
    time.sleep(0.05)
    return n

start = time.perf_counter()
with ThreadPoolExecutor(max_workers=4) as ex:
    print(list(ex.map(io_task, range(4))))
print('ran concurrently')

as_completed

as_completed(futures) menghasilkan setiap masa hadapan sebaik sahaja ia selesai, tanpa mengira susunan penghantaran. Fungsi ini sangat sesuai untuk memproses hasil sebaik sahaja hasil tersebut tiba.

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def work(n):
    time.sleep(0.01 * (3 - n))
    return n

with ThreadPoolExecutor() as ex:
    futures = [ex.submit(work, i) for i in range(3)]
    for f in as_completed(futures):
        print('finished', f.result())

Mengendalikan Pengecualian

Jika tugas mencetuskan pengecualian, pengecualian itu disimpan dalam Future dan dicetuskan semula apabila Anda memanggil .result(). Bungkus panggilan tersebut dalam try/except.

from concurrent.futures import ThreadPoolExecutor

def risky(n):
    if n == 0:
        raise ValueError('cannot be zero')
    return 10 // n

with ThreadPoolExecutor() as ex:
    f = ex.submit(risky, 0)
    try:
        print(f.result())
    except ValueError as e:
        print('caught:', e)

Pemetaan dengan Pelbagai Argumen

map menerima beberapa objek boleh lelar dan memadankannya sebagai argumen, seperti map terbina dalam.

from concurrent.futures import ThreadPoolExecutor

def add(a, b):
    return a + b

with ThreadPoolExecutor() as ex:
    print(list(ex.map(add, [1, 2, 3], [10, 20, 30])))

Mengumpulkan Hasil dalam Kamus

Corak yang biasa digunakan ialah memadankan setiap masa hadapan kembali kepada inputnya supaya Anda tahu hasil yang sepadan apabila menggunakan as_completed.

from concurrent.futures import ThreadPoolExecutor, as_completed

def length(word):
    return len(word)

words = ['cat', 'tiger', 'ox']
with ThreadPoolExecutor() as ex:
    future_to_word = {ex.submit(length, w): w for w in words}
    out = {}
    for f in as_completed(future_to_word):
        out[future_to_word[f]] = f.result()
print(sorted(out.items()))

Penutupan Pengurus Konteks

Menggunakan pelaksana dalam blok with memanggil shutdown() secara automatik dan menunggu semua tugas yang belum selesai untuk diselesaikan.

from concurrent.futures import ThreadPoolExecutor

def job(n):
    return n * 2

with ThreadPoolExecutor() as ex:
    futures = [ex.submit(job, i) for i in range(3)]
print('all tasks done after the with block')
print([f.result() for f in futures])

Menyemak Keadaan Future

Future menyediakan .done() dan .running() supaya Anda boleh memeriksa kemajuan tanpa menyekat pelaksanaan.

from concurrent.futures import ThreadPoolExecutor

def quick(n):
    return n + 1

with ThreadPoolExecutor() as ex:
    f = ex.submit(quick, 41)
    result = f.result()
    print('done?', f.done())
    print('value:', result)

Bila Menggunakannya

ThreadPoolExecutor sangat sesuai untuk banyak tugas kecil yang terikat input/output: panggilan HTTP, pembacaan fail dan pertanyaan pangkalan data. Untuk kerja terikat CPU, gunakan ProcessPoolExecutor sebagai ganti.

from concurrent.futures import ThreadPoolExecutor

urls = ['a', 'b', 'c']

def fetch(u):
    return 'fetched ' + u

with ThreadPoolExecutor(max_workers=3) as ex:
    for r in ex.map(fetch, urls):
        print(r)

Semakan Ringkas

Uji pemahaman anda tentang ThreadPoolExecutor.

Jawab dalam pelajaran interaktif

Ringkasan

Anda telah mempelajari ThreadPoolExecutor:

submit() mengembalikan hasil tertunda; map() memproses objek boleh lelar mengikut turutan.
as_completed() menghasilkan hasil tertunda apabila setiap satunya selesai.
Pengecualian muncul melalui result().
Blok with mengendalikan penutupan.

Seterusnya: keselarian sebenar dengan pemprosesan berbilang.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 76
Pelajaran: 320

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “ThreadPoolExecutor” percuma?

Ya — teks penuh “ThreadPoolExecutor” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Python Academy, tingkat taraf kepada CoddyKit PRO. Kursus Python Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “ThreadPoolExecutor”?

Jalankan tugasan serentak Anda berlatih Python Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Python Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Python Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “ThreadPoolExecutor” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Python Academy