Python Academy · Pelajaran

ThreadPoolExecutor

Jalankan tugas secara bersamaan

ThreadPoolExecutor adalah pelajaran Python Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Python Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Python Academy mencakup 4 pelajaran total.

Mengapa Menggunakan Kumpulan Utas?

Membuat dan menggabungkan utas secara manual melelahkan. concurrent.futures.ThreadPoolExecutor mengelola kumpulan utas pekerja untuk Anda dan mengembalikan hasil dengan rapi.

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() menjadwalkan pemanggilan dan segera mengembalikan Future. Anda memanggil .result() pada objek tersebut untuk mendapatkan nilainya; pemanggilan ini akan memblokir hingga nilainya siap.

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 bersamaan dan menghasilkan hasil dalam urutan 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))

Mengontrol Jumlah Pekerja

max_workers membatasi jumlah utas yang berjalan sekaligus. Untuk pekerjaan yang terikat I/O, Anda dapat menggunakan lebih banyak pekerja daripada jumlah inti 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 future tepat saat selesai, terlepas dari urutan pengirimannya. Fitur ini sangat berguna untuk memproses hasil segera setelah 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())

Menangani Pengecualian

Jika suatu task memunculkan pengecualian, pengecualian tersebut disimpan di dalam Future dan dimunculkan kembali saat Anda memanggil .result(). Bungkus pemanggilan 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)

Melakukan Pemetaan dengan Beberapa Argumen

map menerima beberapa iterable dan memasangkannya sebagai argumen, seperti map bawaan.

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

Pola yang umum adalah memetakan setiap future kembali ke inputnya agar Anda mengetahui hasil yang sesuai saat 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 Pengelola Konteks

Menggunakan executor di dalam blok with akan memanggil shutdown() secara otomatis dan menunggu semua task yang tertunda selesai.

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])

Memeriksa Keadaan Future

Future menyediakan .done() dan .running() sehingga Anda dapat memeriksa kemajuan tanpa memblokir.

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)

Kapan Menggunakannya

ThreadPoolExecutor ideal untuk banyak task kecil yang terikat I/O: pemanggilan HTTP, pembacaan berkas, dan kueri basis data. Untuk pekerjaan yang terikat CPU, gunakan ProcessPoolExecutor sebagai gantinya.

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)

Pemeriksaan Singkat

Uji pemahaman Anda tentang ThreadPoolExecutor.

Ringkasan

Anda mempelajari ThreadPoolExecutor:

submit() mengembalikan objek untuk mengambil hasil nanti; map() berjalan pada objek yang dapat diiterasi secara berurutan.
as_completed() menghasilkan future saat masing-masing selesai.
Pengecualian muncul melalui result().
Blok with menangani penghentian.

Berikutnya: paralelisme sejati dengan multiproses.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “ThreadPoolExecutor” gratis?

Ya — teks lengkap “ThreadPoolExecutor” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Python Academy, upgrade ke CoddyKit PRO. Kursus Python Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “ThreadPoolExecutor”?

Jalankan tugas secara bersamaan Kamu berlatih Python Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Python Academy?

Tidak diperlukan pengalaman sebelumnya. Python Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “ThreadPoolExecutor” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Python Academy ini?

Ya. Setiap pelajaran Python Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Python Academy