Utilisez synchronisé pour contr?ler la granularité, utilisez d'abord les blocs de code synchronisés; Utilisation de classes d'outils telles que ReentrantLock et ConcurrentHashMap dans le package java.util.concurrent; évitez les blocages et utilisez Trylock; Volatile peut assurer une visibilité variable mais ne remplace pas la synchronisation. Plus précisément: 1. Lors de l'utilisation de synchronisés, vous devez hiérarchiser les blocs de code de synchronisation plut?t que la méthode entière pour verrouiller les ressources qui doivent vraiment être protégées; 2. Utilisez ReentrantLock pour fournir un mécanisme de verrouillage plus flexible, ReadWriteLock améliore les performances de Lire la plus et écrivez moins de scènes, et ConcurrentHashMap est plus efficace que SynchronizedMap; 3. Pour éviter les impasses, vous devez unifier l'ordre de verrouillage, réduire la nidification de verrouillage et définir le délai d'attente avec Trylock; 4. Volatile est utilisé pour assurer la visibilité des variables et convient aux variables du drapeau d'état, mais elle n'est pas atomique et doit être utilisée avec des serrures. Le choix raisonnable de mécanisme de synchronisation peut améliorer les performances de la concurrence et assurer la sécurité des filetages.

Le mécanisme de synchronisation de Java est un moyen clé pour garantir la cohérence des données et la sécurité des filetages dans la programmation multi-thread. Si vous ne faites pas attention à la fa?on dont vous l'utilisez, il est facile d'avoir des impasses, des conditions de course ou des goulots d'étranglement des performances. Voici quelques suggestions et pratiques pratiques dans le développement réel.

Contr?ler la granularité lors de l'utilisation de mots clés synchronisés

synchronized est le mécanisme de synchronisation le plus élémentaire en Java. Il est simple à utiliser mais facile à abuser. Beaucoup de gens aiment ajouter directement synchronized à la méthode, mais cela peut rendre la serrure trop grande et affecter les performances de concurrence.

• Prioriser les blocs de code synchrones sur toute la méthode, en verrouillant uniquement les ressources qui doivent vraiment être protégées.
• Si plusieurs threads fonctionnent sur différentes instances d'objet, essayez d'éviter d'utiliser des verrous au niveau de la classe (tels que des méthodes synchronized static ), sinon un blocage inutile peut se produire.

Par exemple:

 public void addData (int value) {
    synchronisé (datalist) {
        datalist.add (valeur);
    }
}

Ceci est plus flexible et plus efficace que l'écriture public synchronized void addData(...) .

Prioriser l'utilisation des classes d'outils dans le package java.util.concurrent

JDK5 présente le package java.util.concurrent , qui contient de nombreuses classes d'outils de concurrence prêtes à l'emploi, telles que ReentrantLock , ReadWriteLock , Semaphore et diverses collections de filetage.

• Reentrantlock fournit un mécanisme de verrouillage plus flexible que les tentatives de support synchronized et soutenues pour acquérir des verrous, des délais d'attente, etc.
• ReadWriteLock peut améliorer considérablement les performances des scénarios où plus de lectures et moins d'écrits.
• En utilisant ConcurrentHashMap au lieu de Collections.synchronizedMap() , il effectue une optimisation de verrouillage de segment plus fin en interne.

Par exemple:

 Lock de reentrantlock final privé = new reentrantLock ();

public void dosomething () {
    lock.lock ();
    essayer {
        // Exécuter le code régional critique} Enfin {
        lock.unlock ();
    }
}

Bien que le code ait quelques lignes supplémentaires, il est plus flexible et convient particulièrement à la logique de synchronisation complexe.

évitez les impasses: faites attention à la commande et à la nidification des serrures

Les impasses sont l'un des problèmes les plus difficiles dans les programmes multi-thread, généralement parce que plusieurs threads demandent plusieurs verrous dans différents ordres.

• Ordre de verrouillage unifié: tous les threads s'appliquent aux verrous dans le même ordre, ce qui peut réduire considérablement la probabilité de blocage.
• Essayez d'éviter d'acquérir une autre serrure avant sa sortie.
• Vous pouvez utiliser tryLock() pour définir l'heure du délai d'expiration. Si vous ne pouvez pas l'obtenir, libérez d'abord les ressources existantes et réessayez.

Par exemple:

 // La mauvaise pratique peut facilement provoquer une impasse Thread1: Locka -> Lockb
Thread2: Lockb -> Locka

// la bonne fa?on de le faire, d'unifier la commande thread1 & thread2: Locka -> Lockb

De plus, l'utilisation d'outils tels que JSTACK ou VisualVM peut aider à analyser l'état du thread et à détecter rapidement des problèmes de blocage potentiels.

N'ignorez pas le r?le de volatile

volatile ne remplace pas le mécanisme de synchronisation, mais il est très utile dans certains cas. Il garantit la visibilité de la variable, c'est-à-dire qu'un thread modifie la variable et les autres threads peuvent voir immédiatement les modifications.

• Applicable aux variables d'indicateur d'état, telles que contr?ler si le thread continue de s'exécuter:

 Running booléen volatile privé = true;

while (running) {
    // faire quelque chose}

public void stop () {
    running = false;
}

Si volatile n'est pas ajouté, la modification de l'exécution par la méthode stop () peut ne pas prendre effet immédiatement, car le thread peut toujours lire la valeur du cache local.

Cependant, il convient de noter que volatile ne garantit pas l'atomicité, et des opérations comme i dois encore être terminée avec des serrures.

Fondamentalement, c'est tout. Le mécanisme de synchronisation Java ne semble pas compliqué, mais il est facile de rester coincé dans une utilisation réelle. La clé est de comprendre les scénarios applicables de chaque mécanisme et de sélectionner les outils appropriés en fonction de la situation réelle du projet.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!