Quels problèmes connaissez-vous liés à la parallélisation?

• Condition de course (Race condition): Plusieurs threads/processus accèdent et modifient simultanément des données partagées, ce qui conduit à des résultats imprévisibles.
• Blocage mutuel (Deadlock): Deux ou plusieurs threads attendent des ressources occupées par d'autres, ce qui entraîne un blocage du système.
• Famine (Starvation): Un thread à faible priorité n'obtient pas l'accès aux ressources, attendant indéfiniment.
• Coûts de synchronisation: L'utilisation de verrouillages et autres primitives de synchronisation nécessite du temps et des ressources, réduisant la performance globale.
• Complexité de débogage: Déboguer du code parallèle est difficile en raison de l'ordre d'exécution imprévisible des threads et de la difficulté à reproduire les problèmes.
• Non déterminisme: Le résultat de l'exécution du programme peut varier à chaque lancement en raison de l'ordre différent d'exécution des threads.
• Scalabilité: Incapacité à faire évoluer la performance proportionnellement au nombre de cœurs en raison de limitations dans l'algorithme ou l'architecture.
• Fausse partage de cache (False sharing): Plusieurs threads accèdent simultanément à des données différentes situées dans la même ligne de cache, provoquant des mises à jour constantes.

Exemple de condition de course:

class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}
// Si deux threads appellent increment() simultanément sans synchronisation,
// la valeur finale de count peut être inférieure à celle attendue.