Utilisation synchronisée

« Salut Amigo ! »

"Oui, je suis là, je suis là."

"Aujourd'hui, je vais vous parler de l'utilisation de la synchronisation dans la pratique."

"Lorsqu'un programme comporte de nombreux objets et threads, il arrive souvent que plusieurs threads fonctionnent simultanément avec le même objet. Ce faisant, les threads interfèrent les uns avec les autres."

"Oui, je le sais déjà."

"Alors, disons que plusieurs threads accèdent à un objet. Vous pouvez faire deux choses pour éviter les problèmes."

"La première consiste à utiliser des blocs synchronisés pour envelopper chaque emplacement où l'objet est accessible. Mais cette approche peut ne pas fonctionner si un programmeur écrit du code qui accède directement à l'objet, sans bloc synchronisé."

"Par conséquent, une deuxième approche est utilisée la plupart du temps : rendre l'objet thread-safe." "En d'autres termes, le mécanisme de synchronisation est intégré à l'objet lui-même : il déclare ses méthodes synchronisées et/ou encapsule le code à l'intérieur de ses méthodes dans des blocs synchronisés."

"Donc, tout objet que je pourrais utiliser à partir de plusieurs threads, et c'est presque tous les objets du programme, je dois le rendre thread-safe?"

"En général, oui. En réalité, tous les objets d'un programme ne sont pas utilisés par différents threads, mais il y en a généralement beaucoup. Ainsi, lorsque vous commencez à écrire du code pour un thread et accédez à divers objets à partir de celui-ci, alors à chaque appel de méthode vous devriez vous demander : « Cet appel est-il sûr ? »"

"Sûr?"

"Thread-safe, ce qui signifie qu'il peut être appelé en toute sécurité à partir de plusieurs threads."

"Voici quelques exemples. Supposons que vous ayez un objet String accessible à partir de différents threads. Comme vous étiez déjà censé vous en souvenir, String est immuable , comme le sont tous les autres types primitifs. Cela signifie qu'un objet ne change pas après sa création. . Cela signifie qu'il est impossible de "casser" un tel objet. Tous les objets immuables sont thread-safe."

"Eh bien, ça facilite les choses."

"Maintenant, supposons que vous ayez besoin d'une chaîne mutable."

"Oui, je me souviens. Il existe deux types de chaînes de ce type : StringBuffer et StringBuilder. StringBuffer est comme StringBuilder, mais toutes ses méthodes sont synchronisées. Est-il également thread-safe ?"

"Oui. Si vous avez besoin d'accéder à un objet StringBuilder à partir de plusieurs threads, vous devez le remplacer par un StringBuffer. Sinon, tôt ou tard, les threads le modifieront en même temps et le "casseront".

"Que se passe-t-il si l'objet auquel on accède à partir de différents threads est un objet de ma propre classe ? Dois-je également ajouter synchronized à ses méthodes dans ce cas ?"

"Oui. Il est préférable de suivre cette règle : tous les objets accessibles à partir de différents threads doivent être thread-safe."

"Je vois. Je ne pensais pas que tout était si sérieux. Merci, Ellie."

"De rien. J'espère que ces conseils vous aideront lorsque Diego vous confiera quelques-unes de ses tâches faciles. ☺"