23. Synchronisation et verrous en Java
La programmation simultanée en Java est un sujet avancé et crucial pour développer des applications robustes et efficaces. Cependant, avec l'exécution de plusieurs threads accédant à des ressources partagées, des défis surviennent liés à la cohérence des données et à la coordination entre les threads. Pour relever ces défis, Java fournit des mécanismes de synchronisation et de verrouillage.
Le problème de la concurrence
Lorsque plusieurs threads fonctionnent sur des données partagées sans synchronisation appropriée, des conditions de concurrence peuvent survenir, dans lesquelles les résultats d'exécution dépendent de l'ordre non déterministe dans lequel les threads sont exécutés. Cela peut conduire à un comportement imprévisible et à des bugs difficiles à reproduire et à corriger.
Mécanismes de synchronisation
Pour éviter les conditions de concurrence, Java propose des mécanismes de synchronisation qui vous permettent de contrôler l'accès aux ressources partagées. La construction principale de la synchronisation en Java est le mot-clé synchronized, qui peut être utilisé pour synchroniser un bloc de code ou une méthode entière.
Méthodes synchronisées
Lorsqu'une méthode est déclarée synchronisée, elle garantit qu'un seul thread à la fois peut l'exécuter sur une instance de la classe. Si la méthode est statique, le blocage se situe au niveau de la classe et non au niveau de l'instance.
public synchronisé vide méthode synchronisée() {
// Code qui manipule la ressource partagée
}
Blocs synchronisés
Au lieu de synchroniser une méthode entière, vous pouvez synchroniser uniquement une section critique de code à l'aide d'un bloc synchronisé. Cela se fait en spécifiant un objet verrou sur lequel le verrou est maintenu.
public void metodoComBlocoSincronizado() {
synchronisé (ce) {
// Section critique du code
}
}
Moniteurs et blocs inhérents
En Java, chaque objet possède un verrou ou un moniteur inhérent, qui est utilisé pour implémenter la synchronisation. Lorsqu'un thread entre dans une méthode ou un bloc synchronisé, il acquiert le verrou associé à l'objet ou à la classe. Les autres threads tentant d'accéder au même bloc ou à la même méthode synchronisée se bloqueront jusqu'à ce que le thread actuel libère le verrou.
Verrous explicites
En plus des verrous inhérents, l'API Java Concurrency (java.util.concurrent) fournit une série de classes de verrouillage explicites qui offrent plus de flexibilité et de contrôle. Les classes ReentrantLock, ReadWriteLock et StampedLock en sont quelques exemples.
importer java.util.concurrent.locks.ReentrantLock ;
classe publique ExempleLock {
verrou ReentrantLock final privé = new ReentrantLock();
méthode public voidComLock() {
lock.lock();
essayer {
// Code protégé par verrou
} enfin {
lock.unlock();
}
}
}
Les verrous explicites offrent des fonctionnalités supplémentaires, telles que la possibilité de tenter d'acquérir un verrou sans attendre indéfiniment (tryLock), la possibilité d'interrompre un thread pendant qu'il attend un verrou (lockInterruptously ) et la possibilité de vérifier si le verrou est maintenu (isLocked).
Conditions et synchronisation fine
Avec la classe ReentrantLock, vous pouvez également créer une ou plusieurs Condition qui fournissent une forme de synchronisation plus fine, permettant aux threads d'attendre des conditions spécifiques ou d'informer d'autres threads de la situation. changements d'état.
importer java.util.concurrent.locks.Condition ;
importer java.util.concurrent.locks.ReentrantLock ;
classe publique ExempleCondition {
verrou ReentrantLock final privé = new ReentrantLock();
condition finale privée condition = lock.newCondition();
public void waitCondicao() lance InterruptedException {
lock.lock();
essayer {
// Attendez que la condition soit satisfaite
condition.attendre();
} enfin {
lock.unlock();
}
}
public void signalCondition() {
lock.lock();
essayer {
// Signale un thread qui attend la condition
condition.signal();
} enfin {
lock.unlock();
}
}
}
Considérations relatives aux performances
La synchronisation a un coût associé en termes de performances, car elle peut réduire la simultanéité et augmenter les temps d'attente des threads. Par conséquent, il est important d'utiliser la synchronisation de manière réfléchie et efficace, en protégeant uniquement les sections critiques du code et en évitant les verrous inutiles.
Bonnes pratiques
- Réduire la portée des blocs synchronisés pour réduire la durée de maintien des verrous.
- Évitez d'effectuer des opérations d'E/S ou des appels réseau.et au sein de blocs synchronisés, car cela peut entraîner des retards importants.
- Envisagez d'utiliser les collections de l'API
java.util.concurrent, qui sont conçues pour être utilisées dans des environnements simultanés sans avoir besoin d'une synchronisation externe. - Soyez conscient des blocages, qui peuvent se produire lorsque deux ou plusieurs threads attendent indéfiniment l'un l'autre pour libérer les verrous.
Conclusion
La synchronisation et les verrous sont des outils essentiels pour la programmation simultanée en Java, permettant aux développeurs de gérer l'accès aux ressources partagées et d'éviter les conditions de concurrence. Cependant, il est important d’utiliser ces mécanismes avec précaution et connaissance, car ils peuvent affecter les performances des applications et conduire à des problèmes complexes tels que des blocages. Avec une solide compréhension des concepts de synchronisation et des API fournies par Java, les développeurs peuvent créer des applications simultanées sécurisées et efficaces.
