1. Synchronicité (Synchronous)
- Définition: Après avoir envoyé une requête, l'appelant doit attendre la fin de celle-ci avant de pouvoir continuer.
- Caractéristiques:
- L'exécution est séquentielle.
- L'appelant attend activement le résultat.
- Tout le temps d'attente est imputé à l'appelant.
int resultat = executeTache(); // Attend jusqu'à ce que executeTache() termine std::cout << "Tâche terminée";
2. Asynchronicité (Asynchronous)
- Définition: Une fois la requête envoyée, l'appelant peut continuer sans attendre, récupérant les résultats via des callbacks, futures ou notifications.
- Caractéristiques:
- L'exécution n'est pas nécessairement séquentielle.
- L'appelant n'est pas bloqué et peut faire autre chose.
- Utilisé pour améliorer l'efficacité ou la réactivité du programme.
std::future<int> futur = std::async(executeTache); // Exécution asynchrone // Autres actions possibles int resultat = futur.get(); // Récupère le résultat
II. Blocage vs Non-blocage
1. Blocage (Blocking)
- Définition: Lorsqu'une condition nécessaire n'est pas satisfaite, le thread courant attend jusqu'à ce qu'elle soit remplie.
- Caractéristiques:
- Le thread actuel arrête son exécution et entre en attente.
- Aucune autre action ne peut être réalisée pendant cette période.
- Souvent utilisé dans les opérations I/O ou pour synchroniser les threads.
std::cin >> entree; // Si l'utilisateur n'entre rien, le programme reste ici
2. Non-blocage (Non-blocking)
- Définition: Même si une condition nécessaire n'est pas satisfaite, l'appel retourne immédiatement avec un code d'erreur ou un état.
- Caractéristiques:
- Le thread actuel n'attend pas.
- Généralement nécessite des tentatives répétées (polling) ou des mécanismes asynchrones.
- Utilisé dans des scénarios à haute concurrence ou sensibles aux performances.
if (donneesDisponibles())
{
lireDonnees(); // Non-bloquant, lit seulement si des données sont disponibles
}
else
{ // Faire autre chose }
III. Combiner ces concepts
| Type | Attend le terme de la tâche ? | Bloque le thread actuel ? | Exemple |
|---|---|---|---|
| Synchronique + Bloquant | Oui | Oui | Appel de fonction normal, lecture de fichier |
| Synchronique + Non-bloquant | Oui | Non (échec rapide) | I/O non-bloquant + mécanisme de polling |
| Asynchronique + Bloquant | Non (tâches parallèles possibles) | Oui (attend le résultat) | futur.get() attend le résultat |
| Asynchronique + Non-bloquant | Non | Non | Tâche asynchrone + mécanisme de callback |
IV. Exemples pratiques
Cas 1: Requête HTTP
Bloquant synchrone:
HttpResponse reponse = client.envoyerRequete(); // Attend jusqu'à ce qu'une réponse soit reçue, bloque le thread
Non-bloquant asynchrone (callback):
client.envoyerRequeteAsync([](HttpResponse reponse)
{ std::cout << "Réponse reçue"; }); // Le thread principal continue
Cas 2: Lecture de fichier
Bloquant synchrone (lecture de fichier courante):
std::ifstream fichier("data.txt");
std::string ligne;
std::getline(fichier, ligne); // Bloque si le fichier n'est pas prêt ou si les données ne sont pas disponibles
I/O non-bloquant (support du système d'exploitation, comme epoll):
int fd = open("data.txt", O_NONBLOCK);
read(fd, tampon, taille); // Retourne -1 immédiatement si aucune donnée n'est disponible