Teknik Python yang hebat untuk Multithreading dan Multiprocessing: Tingkatkan Prestasi Apl Anda

Teroka halaman pengarang Amazon saya untuk pelbagai pilihan buku. Ikuti saya di Medium untuk mendapatkan lebih banyak cerapan dan kemas kini! Sokongan anda amat dihargai.

Buka kunci kuasa keupayaan berbilang benang dan berbilang pemprosesan Python untuk meningkatkan kelajuan dan kecekapan aplikasi anda secara mendadak. Panduan ini mendedahkan lapan teknik penting untuk memanfaatkan ciri ini dengan berkesan.

Threading cemerlang dengan operasi terikat I/O. Modul threading Python menawarkan antara muka mesra pengguna untuk pengurusan benang. Berikut ialah cara memuat turun berbilang fail serentak:

<code class="language-python">import threading
import requests

def download_file(url):
    response = requests.get(url)
    filename = url.split('/')[-1]
    with open(filename, 'wb') as f:
        f.write(response.content)
    print(f"Downloaded {filename}")

urls = ['http://example.com/file1.txt', 'http://example.com/file2.txt', 'http://example.com/file3.txt']

threads = []
for url in urls:
    thread = threading.Thread(target=download_file, args=(url,))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print("All downloads complete")</code>

Kod ini memperuntukkan setiap muat turun ke urutan yang berasingan, membolehkan pelaksanaan serentak.

Untuk tugasan terikat CPU, modul multiprocessing adalah lebih baik kerana Kunci Jurubahasa Global (GIL) Python. Multiprocessing mencipta proses bebas, masing-masing dengan ruang ingatan sendiri dan GIL, mengelakkan batasan GIL. Berikut ialah contoh pengiraan selari:

<code class="language-python">import multiprocessing

def calculate_square(number):
    return number * number

if __name__ == '__main__':
    numbers = range(10)

    with multiprocessing.Pool() as pool:
        results = pool.map(calculate_square, numbers)

    print(results)</code>

Ini menggunakan kumpulan proses untuk mengagihkan pengiraan dengan cekap.

Modul concurrent.futures menyediakan abstraksi peringkat lebih tinggi untuk pelaksanaan tugas tak segerak, berfungsi dengan lancar dengan kedua-dua urutan dan proses. Berikut ialah contoh menggunakan ThreadPoolExecutor:

<code class="language-python">from concurrent.futures import ThreadPoolExecutor
import time

def worker(n):
    print(f"Worker {n} starting")
    time.sleep(2)
    print(f"Worker {n} finished")

with ThreadPoolExecutor(max_workers=3) as executor:
    executor.map(worker, range(5))

print("All workers complete")</code>

Ini menghasilkan kumpulan benang untuk mengurus lima tugas pekerja.

Untuk I/O tak segerak, modul asyncio bersinar, membolehkan pengaturcaraan tak segerak yang cekap dengan coroutine. Berikut ialah contoh:

<code class="language-python">import asyncio
import aiohttp

async def fetch_url(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ['http://example.com', 'http://example.org', 'http://example.net']
    tasks = [fetch_url(url) for url in urls]
    results = await asyncio.gather(*tasks)
    for url, result in zip(urls, results):
        print(f"Content length of {url}: {len(result)}")

asyncio.run(main())</code>

Ini dengan cekap mengambil kandungan daripada berbilang URL serentak.

Perkongsian data antara proses memerlukan alat khusus. Modul multiprocessing menyediakan mekanisme seperti Value untuk memori dikongsi:

<code class="language-python">from multiprocessing import Process, Value
import time

def increment(counter):
    for _ in range(100):
        with counter.get_lock():
            counter.value += 1
        time.sleep(0.01)

if __name__ == '__main__':
    counter = Value('i', 0)
    processes = [Process(target=increment, args=(counter,)) for _ in range(4)]

    for p in processes:
        p.start()

    for p in processes:
        p.join()

    print(f"Final counter value: {counter.value}")</code>

Ini mempamerkan kenaikan balas yang selamat merentas berbilang proses.

Penyegerakan benang menghalang keadaan perlumbaan apabila berbilang benang mengakses sumber kongsi. Python menawarkan primitif penyegerakan seperti Lock:

<code class="language-python">import threading

class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()

    def increment(self):
        with self.lock:
            self.count += 1

def worker(counter, num_increments):
    for _ in range(num_increments):
        counter.increment()

counter = Counter()
threads = []
for _ in range(5):
    thread = threading.Thread(target=worker, args=(counter, 100000))
    threads.append(thread)
    thread.start()

for thread in threads:
    thread.join()

print(f"Final count: {counter.count}")</code>

Contoh ini menggunakan kunci untuk memastikan penambahan pembilang atom.

ProcessPoolExecutor sesuai untuk tugasan terikat CPU. Berikut ialah contoh untuk mencari nombor perdana:

<code class="language-python">from concurrent.futures import ProcessPoolExecutor
import math

def is_prime(n):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0 or n % 3 == 0:
        return False
    i = 5
    while i * i <= n:
        if n % i == 0 or n % (i + 2) == 0:
            return False
        i += 6
    return True

if __name__ == '__main__':
    numbers = range(100000)
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(is_prime, numbers))
    print(sum(results))</code>

Ini mengedarkan semakan nombor perdana merentas berbilang proses.

memilih antara multithreading dan multiprocessing bergantung kepada tugas. Tugas-tugas I/O yang mendapat manfaat daripada multithreading, sementara tugas-tugas CPU yang terikat sering memerlukan multiprocessing untuk paralelisme yang benar. Beban mengimbangi dan kebergantungan tugas adalah pertimbangan penting dalam pemprosesan selari. Mekanisme penyegerakan yang sesuai adalah penting apabila berurusan dengan sumber yang dikongsi. Perbandingan prestasi berbeza -beza berdasarkan tugas dan sistem. Dalam pemprosesan data dan pengkomputeran saintifik, multiprocessing boleh menjadi sangat berkesan. Untuk aplikasi web, menawarkan pengendalian sambungan serentak yang cekap. Alat pemprosesan selari Python memberi kuasa kepada pemaju untuk membuat aplikasi berprestasi tinggi. asyncio

---

101 buku

101 buku

, sebuah rumah penerbitan berkuasa AI yang diasaskan oleh pengarang Aarav Joshi , menawarkan buku yang berpatutan, berkualiti tinggi-beberapa harga serendah $ 4 . Cari

kami Golang Clean Code

buku di Amazon. Cari Aarav Joshi untuk mencari lebih banyak tajuk dan diskaun khas!

Projek kami yang lain

meneroka projek -projek kami yang lain: Pusat Pelabur

(Bahasa Inggeris, Sepanyol, Jerman), Smart Living , Epochs & Echoes , misteri yang membingungkan , , Elite dev , dan sekolah JS .

ikuti kami di medium

---

berhubung dengan kami di Sederhana:

Tech Koala Insights

, Epochs & Echoes World

, Medium Central Investor , Medium Misteri Misteri Sains & Epochs Medium , dan Hindutva moden .

Atas ialah kandungan terperinci Teknik Python yang hebat untuk Multithreading dan Multiprocessing: Tingkatkan Prestasi Apl Anda. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!