# Tingkatkan Tugas Python Anda dengan `ThreadPoolExecutor`

Apabila menjalankan berbilang tugas secara serentak dalam Python, modul concurrent.futures ialah alat yang berkuasa dan mudah. Dalam artikel ini, kami akan meneroka cara menggunakan ThreadPoolExecutor untuk melaksanakan tugas secara selari, bersama-sama dengan contoh praktikal.

Mengapa Menggunakan ThreadPoolExecutor?

Dalam Python, benang sesuai untuk tugas yang operasi I/O mendominasi, seperti panggilan rangkaian atau operasi baca/tulis fail. Dengan ThreadPoolExecutor, anda boleh:

• Jalankan berbilang tugas serentak tanpa mengurus urutan secara manual.
• Hadkan bilangan utas aktif untuk mengelakkan sistem anda membebani.
• Kumpul hasil dengan mudah menggunakan API intuitifnya.

---

Contoh: Menjalankan Tugasan Secara Selari

Mari kita lihat contoh mudah untuk memahami konsepnya.

Kod

from concurrent.futures import ThreadPoolExecutor
import time

# Function simulating a task
def task(n):
    print(f"Task {n} started")
    time.sleep(2)  # Simulates a long-running task
    print(f"Task {n} finished")
    return f"Result of task {n}"

# Using ThreadPoolExecutor
def execute_tasks():
    tasks = [1, 2, 3, 4, 5]  # List of tasks
    results = []

    # Create a thread pool with 3 simultaneous threads
    with ThreadPoolExecutor(max_workers=3) as executor:
        # Execute tasks in parallel
        results = executor.map(task, tasks)

    return list(results)

if __name__ == "__main__":
    results = execute_tasks()
    print("All results:", results)

Output yang Dijangka

Apabila anda menjalankan kod ini, anda akan melihat sesuatu seperti ini (dalam susunan yang agak selari):

Task 1 started
Task 2 started
Task 3 started
Task 1 finished
Task 4 started
Task 2 finished
Task 5 started
Task 3 finished
Task 4 finished
Task 5 finished
All results: ['Result of task 1', 'Result of task 2', 'Result of task 3', 'Result of task 4', 'Result of task 5']

Tugas 1, 2, dan 3 bermula serentak kerana max_workers=3. Tugasan lain (4 dan 5) tunggu sehingga urutan tersedia.

---

Bila Untuk Menggunakannya?

Kes Penggunaan Biasa:

• Mengambil data daripada API: Muatkan berbilang URL serentak.
• Pemprosesan fail: Baca, tulis atau ubah berbilang fail serentak.
• Automasi tugas: Lancarkan berbilang skrip atau arahan secara selari.

---

Amalan Terbaik

1. Hadkan bilangan utas:

   • Terlalu banyak urutan boleh membebankan CPU anda atau mewujudkan kesesakan.

2. Kendalikan pengecualian:

   • Jika satu tugasan gagal, ia boleh menjejaskan keseluruhan kumpulan. Tangkap pengecualian dalam fungsi anda.

3. Gunakan ProcessPoolExecutor untuk tugas terikat CPU:

   • Benang tidak optimum untuk pengiraan berat disebabkan oleh Kunci Jurubahasa Global (GIL) Python.

---

Contoh Lanjutan: Mengambil URL secara Selari

Berikut ialah contoh dunia sebenar: mengambil berbilang URL secara selari.

import requests
from concurrent.futures import ThreadPoolExecutor

# Function to fetch a URL
def fetch_url(url):
    try:
        response = requests.get(url)
        return f"URL: {url}, Status: {response.status_code}"
    except Exception as e:
        return f"URL: {url}, Error: {e}"

# List of URLs to fetch
urls = [
    "https://example.com",
    "https://httpbin.org/get",
    "https://jsonplaceholder.typicode.com/posts",
    "https://invalid-url.com"
]

def fetch_all_urls(urls):
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = executor.map(fetch_url, urls)
    return list(results)

if __name__ == "__main__":
    results = fetch_all_urls(urls)
    for result in results:
        print(result)

Kesimpulan

ThreadPoolExecutor memudahkan pengurusan thread dalam Python dan sesuai untuk mempercepatkan tugas terikat I/O. Dengan hanya beberapa baris kod, anda boleh menyelaraskan operasi dan menjimatkan masa yang berharga.

Atas ialah kandungan terperinci # Tingkatkan Tugas Python Anda dengan `ThreadPoolExecutor`. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!