Techniques Python plus élevées pour le multithreading et le multiprocessement: augmentez les performances de votre application

Explorez ma page d'auteur Amazon pour une large sélection de livres. Suivez-moi sur Medium pour plus d'informations et de mises à jour ! Votre soutien est grandement apprécié.

Débloquez la puissance des capacités multithreading et multitraitement de Python pour améliorer considérablement la vitesse et l'efficacité de votre application. Ce guide dévoile huit techniques essentielles pour exploiter efficacement ces fonctionnalités.

Le threading excelle avec les opérations liées aux E/S. Le module threading de Python offre une interface conviviale pour la gestion des threads. Voici comment télécharger simultanément plusieurs fichiers :

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

Ce code attribue chaque téléchargement à un thread distinct, permettant une exécution simultanée.

Pour les tâches liées au processeur, le module multiprocessing est supérieur grâce au Global Interpreter Lock (GIL) de Python. Le multitraitement crée des processus indépendants, chacun avec son propre espace mémoire et son propre GIL, évitant ainsi les limitations du GIL. Voici un exemple de calcul parallèle :

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

Cela utilise un pool de processus pour distribuer efficacement les calculs.

Le module concurrent.futures fournit une abstraction de niveau supérieur pour l'exécution de tâches asynchrones, fonctionnant de manière transparente avec les threads et les processus. Voici un exemple utilisant 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>

Cela crée un pool de threads pour gérer cinq tâches de travail.

Pour les E/S asynchrones, le module asyncio brille, permettant une programmation asynchrone efficace avec des coroutines. Voici un exemple :

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

Cela récupère efficacement le contenu de plusieurs URL simultanément.

Le partage de données entre processus nécessite des outils spécifiques. Le module multiprocessing fournit des mécanismes comme Value pour la mémoire partagée :

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

Cela présente une incrémentation de compteur sûre sur plusieurs processus.

La synchronisation des threads empêche les conditions de concurrence lorsque plusieurs threads accèdent à des ressources partagées. Python propose des primitives de synchronisation comme 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>

Cet exemple utilise un verrou pour garantir les incréments du compteur atomique.

ProcessPoolExecutor est idéal pour les tâches liées au processeur. Voici un exemple pour trouver des nombres premiers :

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

Cela répartit la vérification des nombres premiers sur plusieurs processus.

Choisir entre le multithreading et le multiprocessement dépend de la tâche. Les tâches liées aux E / O bénéficient d'un multithreading, tandis que les tâches liées au CPU nécessitent souvent un multiprocessement pour le véritable parallélisme. L'équilibrage des charges et les dépendances des tâches sont des considérations cruciales dans le traitement parallèle. Les mécanismes de synchronisation appropriés sont essentiels lorsqu'ils traitent des ressources partagées. Les comparaisons de performances varient en fonction de la tâche et du système. Dans le traitement des données et l'informatique scientifique, le multiprocessement peut être très efficace. Pour les applications Web, asyncio offre une gestion efficace des connexions simultanées. Les divers outils de traitement parallèles de Python permettent aux développeurs de créer des applications haute performance.

---

101 livres

101 livres , une maison d'édition propulsée par l'AI co-fondée par l'auteur aarav joshi , propose des livres abordables et de haute qualité - un prix aussi bas que 4 $ .

Découvrez notre Golang Clean Code réserver sur Amazon. Recherchez aarav joshi pour trouver plus de titres et de remises spéciales!

nos autres projets

Explorez nos autres projets: Investor Central (anglais, espagnol, allemand), Smart Living , Epochs & Echoes , Mystères perplexes , hindutva , elite dev , et js écoles .

---

Suivez-nous sur moyen

Connectez-vous avec nous sur Medium: Tech Koala Insights , Epochs & Echoes World , Investor Central Medium , Puzzling Mysteries Medium ,, Science et époques médium , et Hindutva moderne .

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!