Concurrence vs. Parallélisme – Définition et Différences

Ce blog discutera en détail de la concurrence et du parallélisme pour vous aider à choisir le meilleur concept pour votre application.

Qu’est-ce que la Concurrence ?

En termes simples, la concurrence est un concept utilisé dans le développement de logiciels pour gérer plusieurs tâches simultanément. Cependant, en théorie, cela ne signifie pas exécuter toutes les tâches en même temps. Au lieu de cela, cela permet au système ou à l’application de gérer plusieurs tâches simultanément en passant rapidement de l’une à l’autre, créant ainsi l’illusion d’un traitement parallèle. Ce processus est également connu sous le nom d’entrelacement des tâches.

Par exemple, considérez un serveur web qui doit gérer plusieurs demandes d’utilisateurs.

• L’utilisateur 1 envoie une demande au serveur pour récupérer des données.
• L’utilisateur 2 envoie une demande au serveur pour télécharger un fichier.
• L’utilisateur 3 envoie une demande au serveur pour récupérer des images.

Sans concurrence, chaque utilisateur doit attendre que la demande précédente soit terminée.

• Étape 1 : Le CPU commence à traiter la demande de récupération de données dans le thread 1.
• Étape 2 : Pendant que le thread 1 attend le résultat, le CPU commence le processus de téléchargement de fichier dans le thread 2.
• Étape 3 : Pendant que le thread 2 attend que le fichier soit téléchargé, le CPU commence la récupération d’images dans le thread 3.
• Étape 4 : Ensuite, le CPU passe entre ces 3 threads en fonction de la disponibilité des ressources pour terminer les 3 tâches simultanément.

Comparé à l’approche d’exécution synchrone, l’approche de concurrence est beaucoup plus rapide et extrêmement utile pour les environnements à cœur unique afin d’améliorer le temps de réponse global du système, l’utilisation des ressources et les capacités de débit du système. Cependant, la concurrence n’est pas limitée aux cœurs uniques; elle peut également être mise en œuvre dans des environnements multi-cœurs.

Cas d’utilisation de la Concurrence

• Interfaces utilisateur réactives.
• Serveurs web.
• Systèmes en temps réel.
• Opérations réseau et I/O.
• Traitement en arrière-plan.

Différents Modèles de Concurrence

Avec la complexité croissante et les exigences des applications modernes, les développeurs ont introduit de nouveaux modèles de concurrence pour pallier les lacunes de l’approche traditionnelle. Voici quelques modèles de concurrence clés et leurs utilisations :

1. Multitâche Coopératif

Dans ce modèle, les tâches cèdent volontairement le contrôle au planificateur à des moments appropriés, lui permettant de traiter d’autres tâches. Cette cession se produit souvent lorsque la tâche est inactive ou en attente d’opérations I/O. C’est l’un des modèles les plus simples à mettre en œuvre, car le changement de contexte est géré au sein du code de l’application.

Exemples :

• Systèmes embarqués légers
• Premières versions de Microsoft Windows (Windows 3.x)
• Mac OS classique

Applications Réelles :

• Applications utilisant des coroutines comme Python asyncio et Kotlin coroutines.

2. Multitâche Préemptif

Le système d’exploitation ou le planificateur d’exécution force les tâches à s’arrêter et alloue du temps CPU à d’autres tâches en fonction d’un algorithme de planification. Ce modèle garantit que toutes les tâches obtiennent une part égale du temps CPU. Cependant, il nécessite des changements de contexte plus complexes.

Exemples :

• Threads Java gérés par la JVM.
• Module de threading en Python.

Applications Réelles :

• Systèmes d’exploitation modernes (Windows, macOS, Linux)
• Serveurs web.

3. Concurrence Événementielle

Dans ce modèle, les tâches sont divisées en petites opérations non-bloquantes et mises en file d’attente. Ensuite, elles obtiennent des tâches de la file, effectuent l’action requise et passent à la suivante, gardant le système interactif.

Exemples :

• Node.js (runtime JavaScript).
• Patron async/await de JavaScript.
• Bibliothèque asyncio de Python.

Applications Réelles :

• Serveurs web comme Node.js.
• Applications de chat en temps réel.

4. Modèle Acteur

Utilise des acteurs pour envoyer et recevoir des messages de manière asynchrone. Chaque acteur traite un message à la fois, évitant l’état partagé et réduisant le besoin de verrous.

Exemples :

• Framework Akka (Java/Scala).
• Langage de programmation Erlang.
• Microsoft Orleans (applications distribuées .NET).

Applications Réelles :

• Systèmes distribués.
• Systèmes de télécommunications.
• Systèmes de traitement des données en temps réel.

5. Programmation Réactive

Ce modèle vous permet de créer des flux de données (observables) et de définir comment ils doivent être traités (opérateurs) et réagir (observateurs). Des changements de données ou des événements se produisent, qui se propagent automatiquement à travers les flux à tous les observateurs abonnés. Cette approche facilite la gestion des données et des événements asynchrones, offrant un moyen propre et déclaratif de gérer des flux de données complexes.

Exemples :

• RxJava
• Reactor
• ReactiveX

Applications Réelles :

• Pipeline de traitement des données en temps réel.
• Interfaces utilisateur interactives.
• Applications nécessitant une gestion dynamique et réactive des données.

Qu’est-ce que le Parallélisme ?

Le parallélisme est un autre concept populaire utilisé dans le développement de logiciels pour gérer plusieurs tâches simultanément. Contrairement à la concurrence, qui crée l’illusion d’un traitement parallèle en passant rapidement d’une tâche à l’autre, le parallélisme exécute réellement plusieurs tâches simultanément en utilisant plusieurs cœurs ou processeurs de CPU. Il implique de diviser des tâches plus grandes en sous-tâches plus petites et indépendantes qui peuvent être exécutées en parallèle. Ce processus est connu sous le nom de décomposition des tâches.

Par exemple, considérez une application de traitement de données qui génère des rapports après avoir effectué des analyses et exécuté des simulations. Sans parallélisme, cela fonctionnerait comme une grande tâche unique, prenant beaucoup de temps à terminer. Mais, si vous optez pour le parallélisme, cela accomplira la tâche beaucoup plus rapidement grâce à la décomposition des tâches.

Voici comment fonctionne le parallélisme :

• Étape 1 : Divisez la tâche principale en sous-tâches indépendantes. Ces sous-tâches doivent pouvoir s’exécuter sans attendre les entrées d’autres tâches. Cependant, s’il y a des dépendances, vous devez les planifier en conséquence pour vous assurer qu’elles sont exécutées dans le bon ordre. Dans cet exemple, je supposerai qu’il n’y a pas de dépendances entre les sous-tâches.
• Sous-tâche 1 : Effectuer l’analyse des données.
• Sous-tâche 2 : Générer des rapports.
• Sous-tâche 3 : Exécuter des simulations.
• Étape 2 : Assigner 3 sous-tâches à 3 cœurs.
• Étape 3 : Enfin, combinez les résultats de chaque sous-tâche pour obtenir le résultat final de la tâche initiale.

Cas d’utilisation du Parallélisme

• Calculs scientifiques et simulations.
• Traitement des données.
• Traitement des images.
• Apprentissage automatique.
• Analyse des risques.

Différents Modèles de Parallélisme

Similaire à la concurrence, le parallélisme a également plusieurs modèles différents pour utiliser efficacement les processeurs multi-cœurs et les ressources informatiques distribuées. Voici quelques modèles clés de parallélisme et leurs utilisations :

1. Parallélisme des Données

Ce modèle distribue les données sur plusieurs processeurs et effectue la même opération sur chaque sous-ensemble de données simultanément. Il est particulièrement efficace pour les tâches qui peuvent être facilement divisées en sous-tâches indépendantes.

Exemples :

• SIMD (Single Instruction, Multiple Data) opérations.
• Traitement parallèle des tableaux.
• Framework MapReduce.

Applications Réelles :

• Traitement des images et des signaux
• Analyse de données à grande échelle
• Simulations scientifiques

2. Parallélisme des Tâches

Le parallélisme des tâches consiste à diviser la tâche globale en tâches plus petites et indépendantes qui peuvent être exécutées simultanément sur différents processeurs. Chaque tâche effectue une opération différente.

Exemples :

• Parallélisme basé sur les threads en Java.
• Tâches parallèles en .NET.
• Threads POSIX.

Applications Réelles :

• Serveurs web traitant plusieurs demandes de clients.
• Implémentations d’algorithmes parallèles.
• Systèmes de traitement en temps réel.

3. Parallélisme en Pipeline

Dans le parallélisme en pipeline, les tâches sont divisées en étapes, et chaque étape est traitée en parallèle. Les données circulent à travers le pipeline, chaque étape fonctionnant simultanément.

Exemples :

• Commandes de pipeline Unix.
• Pipelines de traitement d’images.
• Pipelines de traitement des données dans les outils ETL (Extract, Transform, Load).

Applications Réelles :

• Traitement vidéo et audio.
• Applications de streaming de données en temps réel.
• Automatisation des lignes de fabrication et d’assemblage.

4. Modèle Fork/Join

Ce modèle consiste à diviser une tâche en sous-tâches plus petites (forking), à les exécuter en parallèle, puis à combiner les résultats (joining). Il est utile pour les algorithmes de diviser pour régner.

Exemples :

• Framework Fork/Join en Java.
• Algorithmes récursifs parallèles (par exemple, tri par fusion parallèle).
• Intel Threading Building Blocks (TBB).

Applications Réelles :

• Tâches de calcul complexes comme le tri de grands ensembles de données.
• Algorithmes récursifs.
• Calculs scientifiques à grande échelle.

5. Parallélisme GPU

Le parallélisme GPU exploite les capacités de traitement massivement parallèle des unités de traitement graphique (GPU) pour exécuter des milliers de threads simultanément, ce qui le rend idéal pour les tâches hautement parallèles.

Exemples :

• CUDA (Compute Unified Device Architecture) par NVIDIA.
• OpenCL (Open Computing Language).
• TensorFlow pour le deep learning.

Applications Réelles :

• Apprentissage automatique et deep learning.
• Rendu graphique en temps réel.
• Calcul scientifique haute performance.

Concurrence vs. Parallélisme

Maintenant que vous avez une bonne compréhension de la manière dont fonctionnent la concurrence et le parallélisme, comparons-les dans plusieurs aspects pour voir comment nous pouvons tirer le meilleur parti des deux.

1. Utilisation des Ressources

• Concurrence : Exécute plusieurs tâches sur un seul cœur, partageant les ressources entre les tâches. Par exemple, le CPU bascule entre les tâches pendant les périodes d’inactivité ou d’attente.
• Parallélisme : Utilise plusieurs cœurs ou processeurs pour exécuter des tâches simultanément.

2. Objectif

• Concurrence : Se concentre sur la gestion de plusieurs tâches en même temps.
• Parallélisme : Se concentre sur l’exécution de plusieurs tâches en même temps.

3. Exécution des Tâches

• Concurrence : Les tâches sont exécutées de manière entrelacée. Le changement rapide de contexte de la CPU crée l’illusion d’une exécution parallèle.
• Parallélisme : Les tâches sont exécutées de manière véritablement parallèle sur différents processeurs ou cœurs.

4. Changement de Contexte

• Concurrence : Des changements de contexte fréquents se produisent lorsque le CPU bascule entre les tâches pour donner l’apparence d’une exécution simultanée. Parfois, cela peut affecter négativement les performances si les tâches deviennent fréquemment inactives.
• Parallélisme : Peu ou pas de changement de contexte, car les tâches fonctionnent sur des cœurs ou des processeurs séparés.

5. Cas d’Utilisation

• Concurrence : Tâches liées aux entrées/sorties (I/O) telles que les opérations sur disque, la communication réseau ou les entrées utilisateur.
• Parallélisme : Tâches liées au CPU nécessitant un traitement intensif comme les calculs mathématiques, l’analyse de données et le traitement d’images.

Peut-on Utiliser la Concurrence et le Parallélisme Ensemble ?

Sur la base de la comparaison ci-dessus, nous pouvons constater que la concurrence et le parallélisme se complètent dans de nombreuses situations. Mais avant de passer à des exemples concrets, voyons comment cette combinaison fonctionne sous le capot dans un environnement multi-cœurs. Pour cela, considérons un serveur web qui effectue la lecture, l’écriture et l’analyse des données.

Étape 1 : Identification des Tâches

Tout d’abord, vous devez identifier les tâches liées aux I/O et les tâches liées au CPU dans votre application. Dans ce cas :

• I/O liées – Lecture et écriture de données.
• CPU liées – Analyse de données.

Étape 2 : Exécution Concurrente

Les tâches de lecture et d’écriture de données peuvent être exécutées dans des threads séparés au sein d’un seul cœur, car elles sont liées aux I/O. Le serveur utilise une boucle d’événements pour gérer ces tâches et passer rapidement entre les threads, entrelaçant l’exécution des tâches. Vous pouvez utiliser une bibliothèque de programmation asynchrone comme Python asyncio pour implémenter ce comportement de concurrence.

Étape 3 : Exécution Parallèle

Plusieurs cœurs peuvent être affectés aux tâches liées au CPU pour les traiter en parallèle. Dans ce cas, l’analyse des données peut être divisée en plusieurs sous-tâches et chaque sous-tâche sera exécutée dans un cœur indépendant. Vous pouvez utiliser un framework d’exécution parallèle comme Python concurrent.futures pour implémenter ce comportement.

Étape 4 : Synchronisation et Coordination

Parfois, les threads s’exécutant sur différents cœurs peuvent dépendre les uns des autres. Dans de telles situations, des mécanismes de synchronisation tels que les verrous et les sémaphores sont nécessaires pour garantir l’intégrité des données et éviter les conditions de concurrence.

Le code ci-dessous montre comment utiliser la concurrence et le parallélisme dans la même application en utilisant Python :

import asyncio
from concurrent.futures import ProcessPoolExecutor
import os

# Simuler une tâche liée aux I/O (lecture de données)
async def read_data():
    await asyncio.sleep(1)  # Simuler un délai d'I/O
    data = [1, 2, 3, 4, 5]  # Données fictives
    print("Lecture de données terminée")
    return data

# Simuler une tâche liée aux I/O (écriture de données)
async def write_data(data):
    await asyncio.sleep(1)  # Simuler un délai d'I/O
    print(f"Écriture de données terminée : {data}")

# Simuler une tâche liée au CPU (analyse des données)
def analyze_data(data):
    print(f"Analyse des données commencée sur le CPU : {os.getpid()}")
    result = [x ** 2 for x in data]  # Simuler une computation
    print(f"Analyse des données terminée sur le CPU : {os.getpid()}")
    return result

async def handle_request():
    # Concurrence : Lire les données de manière asynchrone
    data = await read_data()

    # Parallélisme : Analyser les données en parallèle
    loop = asyncio.get_event_loop()
    with ProcessPoolExecutor() as executor:
        analyzed_data = await loop.run_in_executor(executor, analyze_data, data)

    # Concurrence : Écrire les données de manière asynchrone
    await write_data(analyzed_data)

async def main():
    # Simuler la gestion de plusieurs demandes
    await asyncio.gather(handle_request(), handle_request())

# Exécuter le serveur
asyncio.run(main())

Exemples Réels de Combinaison de Concurrence et Parallélisme

Voyons maintenant quelques cas d’utilisation courants où nous pouvons combiner la concurrence et le parallélisme pour obtenir des performances optimales.

1. Traitement des Données Financières

Les principales tâches d’un système de traitement des données financières incluent la collecte, le traitement et l’analyse des données tout en servant les opérations quotidiennes.

• La concurrence est utilisée pour récupérer des données financières à partir de diverses ressources telles que le marché boursier en utilisant des opérations I/O asynchrones.
• Analyser les données collectées pour générer des rapports. C’est une tâche intensive en CPU, et le parallélisme est utilisé pour l’exécuter en parallèle sans affecter les opérations quotidiennes.

2. Traitement Vidéo

Les principales tâches d’un système de traitement vidéo incluent le téléchargement, le codage/décodage et l’analyse des fichiers vidéo.

• La concurrence peut être utilisée pour gérer plusieurs demandes de téléchargement vidéo en utilisant des opérations I/O asynchrones. Cela permet aux utilisateurs de télécharger des vidéos sans attendre la fin des autres téléchargements.
• Le parallélisme est utilisé pour les tâches intensives en CPU telles que le codage, le décodage et l’analyse des fichiers vidéo.

3. Collecte de Données

Les principales tâches d’un service de collecte de données incluent la récupération de données à partir de divers sites web et le traitement/analyse des données collectées pour obtenir des informations.

• La collecte de données peut être gérée en utilisant la concurrence. Elle garantit que la collecte de données est efficace et n’est pas bloquée en attendant des réponses.
• Le parallélisme est utilisé pour traiter les données collectées sur plusieurs cœurs de CPU. Il améliore le processus de prise de décision de l’organisation en fournissant des rapports en temps réel.

Conclusion

La concurrence et le parallélisme sont deux concepts clés utilisés dans le développement de logiciels pour améliorer les performances des applications. La concurrence permet d’exécuter plusieurs tâches simultanément, tandis que le parallélisme accélère le traitement des données en utilisant plusieurs cœurs de CPU. Bien qu’ils aient des fonctionnalités distinctes, leur intégration peut améliorer considérablement les performances des applications avec des tâches à la fois liées aux I/O et au CPU.

Les outils de Bright Data, comme les Web Scraper APIs, les Web Scraper Functions et le Scraping Browser, sont conçus pour exploiter pleinement ces techniques. Ils utilisent des opérations asynchrones pour collecter des données de plusieurs sources simultanément et le traitement parallèle pour analyser et organiser rapidement les données. Ainsi, choisir un fournisseur de données comme Bright Data, qui a déjà intégré la concurrence et le parallélisme dans son noyau, peut vous faire gagner du temps et des efforts, car vous n’aurez pas besoin de mettre en œuvre ces concepts à partir de zéro lors du scraping de données.

Commencez votre essai gratuit dès aujourd’hui!