Mesure de la performance

Vous pouvez utiliser les méthodes nanoTime() ou System.currentTimeMillis() pour mesurer le temps d'exécution du code multithreadé.

Remarque

Dans cette vidéo, le code compare la performance de la sommation multithreadée et monothreadée des éléments d'un tableau en Java. Il initialise un tableau avec des entiers aléatoires, distribue la tâche entre plusieurs threads pour calculer la somme en parallèle, puis effectue la même sommation de manière séquentielle pour mesurer et comparer les temps d'exécution.

Concurrences de Données

Les conditions de concurrence surviennent dans les programmes multithreadés lorsque deux ou plusieurs threads tentent simultanément d'opérer sur une ressource partagée sans synchronisation appropriée. Cela peut entraîner un comportement de programme imprévisible et incorrect car les résultats dépendent de la manière dont les threads s'exécutent en parallèle et de la rapidité avec laquelle ils accèdent à la ressource partagée.

Ce problème a été discuté dans la section précédente, où il a été montré comment résoudre le problème en utilisant le mot-clé synchronized.

Comportement Imprévisible

Un comportement imprévisible peut survenir en raison d'une synchronisation incorrecte. Par exemple, l'absence de synchronisation peut amener les threads à travailler avec des données obsolètes.

Dans cette vidéo, le code démontre le problème de comportement imprévisible dans les applications multithread causé par l'accès à un état partagé non synchronisé.

Décision

Ce problème peut être résolu en utilisant le mot-clé volatile. Une variable déclarée comme volatile peut être modifiée par plusieurs threads simultanément. Cela garantit que la valeur de la variable sera immédiatement visible pour tous les autres threads après la modification.

Mais vous n'avez pas besoin de déclarer tous les champs avec volatile

Les variables déclarées comme volatile sont synchronisées avec la mémoire principale à chaque accès en lecture et écriture. Cela signifie que lorsqu'un thread met à jour la valeur d'une variable volatile, le changement est immédiatement visible pour tous les autres threads, améliorant ainsi la visibilité. Cependant, cela signifie également que les lectures peuvent être plus lentes, donc utilisez volatile uniquement lorsque c'est nécessaire.

Deadlock

Un deadlock se produit lorsque deux ou plusieurs threads se retrouvent bloqués en attendant que les autres libèrent des ressources.

Dans la vidéo, nous avons rencontré un blocage lorsque deux threads ont simultanément verrouillé les moniteurs d'objets dans différentes séquences, conduisant à une situation où les threads attendaient simplement que l'autre libère les moniteurs dont ils avaient besoin.

Pour résoudre ce problème, nous devons nous assurer que de telles situations ne se produisent pas. Nous pouvons y parvenir en veillant à ce que tous les threads verrouillent les moniteurs des objets dans le même ordre.

Dans ce cas, le premier thread qui verrouille le moniteur d'un objet empêchera les autres threads de verrouiller ce même moniteur, les obligeant à attendre jusqu'à ce que le premier thread termine sa tâche. Ce n'est qu'après que le premier thread aura terminé qu'il libérera le moniteur, permettant aux autres threads de continuer.

Éviter les problèmes de multithreading

Synchronisation des données : Utilisez le mot-clé synchronized pour les méthodes et les blocs de code afin de prévenir les conflits de données.

Évitez le verrouillage mutuel : Assurez-vous que tous les threads acquièrent les ressources dans le même ordre.