Java éviter condition de course SANS synchronisé/verrouillage

Afin d'éviter condition de course, nous pouvons synchroniser les écrire et les méthodes d'accès sur les variables partagées, pour verrouiller ces variables pour les autres threads.

Ma question est si il y a d'autres (mieux) les moyens d'éviter condition de course? Verrouillage de rendre le programme lente.

Ce que j'ai trouvé sont:

  • Atomique à l'aide de classes, si il y a une seule variable partagée.
  • à l'aide d'un immuable conteneur pour le multi variables partagées et de déclarer cet objet conteneur avec des volatiles. (J'ai trouvé cette méthode à partir du livre "Java Simultanéité dans la Pratique")

Je ne suis pas sûr si ils effectuent plus vite que syncnronized façon, est-il d'autres méthodes?

grâce

Ceux-ci sont à la fois de bonnes solutions de rechange. Il existe de nombreuses solutions de rechange qui peuvent être utilisés. L'applicabilité de chaque dépendra de votre situation et exactement ce que vous essayez d'atteindre. Pourriez-vous nous donner un peu plus de détails?

OriginalL'auteur cn1h | 2011-12-01

  1. 3

    Atomics sont en effet plus efficace que le classique serrures en raison de leur non-blocage de comportement c'est à dire un fil d'attente pour accéder à l'emplacement de la mémoire ne sera pas le contexte de commutation, ce qui permet d'économiser beaucoup de temps.

    Probablement le meilleur guide lors de la synchronisation est nécessaire, c'est de voir comment vous pouvez réduire la section critique de la taille autant que possible. Les idées générales comprennent:

    1. Utiliser des verrous en lecture /écriture au lieu de plein de serrures lorsque seule une partie des threads besoin d'écrire.
    2. Trouver des moyens pour restructurer le code afin de réduire la taille des sections critiques.
    3. Utilisation atomics lors de la mise à jour d'une seule variable.
    4. Noter que certains algorithmes et structures de données qui, traditionnellement, ont besoin de serrures verrouillage des versions gratuites (ils sont plus compliqués cependant).
    "3. Utilisation atomics lors de la mise à jour d'une seule variable." Si il y a plus de variables, mais elles sont indépendantes (jamais être utilisé de la même fonction), puis-je utiliser atomics ainsi?
    Oui, bien sûr. Mais vous aurez besoin d'utiliser atomics pour chacun d'eux.

    OriginalL'auteur Tudor

  2. 6

    Éviter d'état. Faites votre demande en tant qu'apatrides que c'est possible. Chaque thread (séquence d'actions) doivent tenir un contexte au début et à utiliser ce contexte, passant d'une méthode à l'un des paramètres.

    Lorsque cette technique ne permet pas de résoudre tous vos problèmes d'utilisation événement piloté par le mécanisme. Lorsque votre code est de partager quelque chose avec d'autres composants, il jette de l'événement (message) à un certain type de bus (sujet, de la file d'attente, peu importe). Les composants peuvent enregistrer des écouteurs pour écouter les événements et réagir de façon appropriée. Dans ce cas, il n'y a pas de conditions de course (à l'exception de l'insertion des événements de la file d'attente). Si vous utilisez de prêt-à-utilisation de la file d'attente et pas de codage de vous-même, il devrait être assez efficace.

    Également prendre un coup d'oeil sur les Acteurs de modèle.

    Je ne pense pas que le remplacement de Java interne du moniteur de verrouillage externe avec les files d'attente/même-driven-mécanismes d'améliorer les performances. La présentation de la demande complètement apatrides peut-être pas une option ici, que le demandeur indique déjà qu'il a données à partager entre les threads. L'Acteur modèle pourrait être utile autant que le code de la propreté, mais encore une fois, je pense que la charge supplémentaire ne bénéficiera pas vers la performance.
    Bodnarescu, je suis absolument d'accord avec vous. Je doute de moi-même exprimé pas exactement. Les performances ici n'est pas le principal problème. Code de la clarté, de la modularité et de la managebility sont beaucoup plus importants. Je voulais juste dire que l'utilisation de l'événement en voiture approche ne sera pas diminuer les performances que certains peur aux gens.
    D'accord, et si je peux ajouter, à la Scala Acteurs de la mise en œuvre du modèle est assez agréable. Et depuis la Scala est une étape loin de Java pour développeur Java, qui pourrait être une option.
    à propos de "rendre l'application apatrides", si je n'ai pas de données partagées entre les threads, mais j'ai quelque chose de partagé entre les fonctions dans le même thread, je devrais utiliser ThreadLocal classe, non?

    OriginalL'auteur AlexR

  3. 2

    Bien, tout d'abord Atomique classes utilise de verrouillage (via synchronisée et de la volatilité des mots-clés) que vous feriez si vous l'avez fait vous-même à la main.

    Deuxième, l'immuabilité fonctionne très bien pour le multi-threading, vous n'avez plus besoin de surveiller les verrous et, mais c'est parce que vous ne pouvez lire votre immutables, vous cand les modifier.

    Vous ne pouvez pas vous débarrasser de synchroniser/volatile, si vous voulez éviter des conditions de course dans un multithread programme Java (c'est à dire si plusieurs threads cand lire ET d'ÉCRIRE les mêmes données). Votre meilleur pari est que si vous voulez améliorer les performances, pour éviter au moins certains de la construction dans le thread-safe classes qui ne sorte plus générique de verrouillage, et de faire votre propre mise en œuvre qui est plus liée à votre contexte et peut ainsi vous permettre d'utiliser plus granullar synchronisation & verrouillage de l'acquisition.

    Découvrez cette mise en œuvre de BlockingCache fait par le Ehcache les gars;

    http://www.massapi.com/source/ehcache-2.4.3/src/net/sf/ehcache/constructs/blocking/BlockingCache.java.html

    Atomique-classes ne sont pas (en général), l'utilisation synchronisée. Leurs valeurs sont volatiles, c'est correct. Au lieu de la synchronisation du soleil.misc.Dangereux de Classe est utilisée, ce qui n'est le CAS-les opérations que le code natif. Donc, si la plate-forme en cours d'exécution sur votre soutient atomique CAS-opérations en assembleur, son plus que probable que le sont utilisées à la place de la synchronisation.

    OriginalL'auteur Shivan Dragon

  4. 2

    L'une des alternatives est de faire partagé des objets immuables. Découvrez ce post pour plus de détails.

    OriginalL'auteur Santosh

  5. 1

    Vous pouvez effectuer jusqu'à 50 millions de verrouiller/déverrouiller par seconde. Si vous voulez que ce soit plus efficace, je vous conseille d'utiliser plus de cours de grain de verrouillage. c'est à dire ne pas verrouiller chaque petite chose, mais ont des serrures pour des objets plus grands. Une fois que vous avez beaucoup plus de verrous que les threads, vous êtes moins susceptibles d'avoir de contention et d'avoir plus de verrous peut juste ajouter les frais généraux.

    OriginalL'auteur Peter Lawrey