AtomicInteger et volatile

Je sais volatile permet de visibilité, AtomicInteger permet l'atomicité.
Donc, si j'utilise un volatile AtomicInteger, ça veut dire je n'ai pas encore utiliser la synchronisation mécanismes?

Par exemple. 

class A {

    private volatile AtomicInteger count;

    void someMethod(){
        //do something
        if(count.get() < 10) {
            count.incrementAndGet();
        }
}

Est ce thread-safe?

  • Qu'entendez-vous par "thread-safe" ici? Il n'y a aucune garantie que le code ci-dessus signifie count ne va jamais au-dessus de 10, par exemple - plusieurs threads peuvent appeler intValue(), et puis tous les appels incrementAndGet().
  • Exactement, il en sera de ce travail? if(count.get() <10){ count.incrementAndGet(); } je crois que j'ai encore besoin d'une couche de synchronisation autour, n'est-ce pas?
  • Je ne peux pas donner une réponse sur ce qui va "travailler" jusqu'à ce que vous donnez exigences. Il va compiler? Oui. Seront à éviter toutes les incréments de se perdre? Oui. Il va faire ce que vous voulez? Je ne peux pas dire.
  • Je voulais dire "thread-safe"? Ce sens est-il sécuritaire de la perte de mises à jour?
  • Oui, mais vous pourriez vous retrouver avec un nombre qui est plus grand que 10.
  • Yep, bien comprise, il en aurait encore besoin d'une synchronisé bloc autour AtomicInteger. Merci beaucoup @JonSkeet
  • Pas nécessairement. Cela dépend de vos besoins, que vous n'avez pas encore donné. À l'aide de compareAndSet dans une boucle, vous pouvez vous assurer que vous n'allez jamais au-dessus de 10. Mais je ne vais pas commencer à écrire un exemple de code pour vous aider à résoudre un problème que vous n'avez pas spécifié de façon suffisamment claire.
  • les conditions sont simples. Il doit être thread-safe, maintenant, que voulez-vous dire par là? À mon humble avis, depuis que je suis en train de faire un simple check-puis-loi, il "semble" que je ne veux pas de quelqu'un pour obtenir de count >10 et ce qui se passe dans un multi-thread env.("évidemment") . Merci pour toutes vos réponses, cependant.
  • Non, rien de tout cela est évident. Il y a des situations où il pourrait être bien pour aller au-dessus d'une limite souple, mais pas bien de perdre le nombre de fois que vous avez dépassé cette limite. Compte tenu de vos besoins réels, je vous suggère de vous poser une nouvelle question à ces exigences, laissant celui-ci comme il est.

InformationsquelleAutor Achow | 2013-01-15
  1. 50

    Je crois que Atomic*, de fait, donne les deux l'atomicité et la volatilité. Ainsi, lorsque vous appelez le (dire) AtomicInteger.get(), vous êtes garanti d'obtenir la dernière valeur. Ceci est documenté dans le java.util.concurrent.atomic la documentation du paquet:

    Les effets de mémoire pour les accès et les mises à jour de atomics généralement de suivre les règles pour les volatiles, comme indiqué dans l'article 17.4 de L'Java™ Langage de Spécification.

    • a la mémoire des effets de la lecture d'une variable volatile.
    • a les effets de mémoire de l'écriture (attribution) d'une variable volatile.
    • lazySet a la mémoire des effets de l'écriture (attribution) d'une variable volatile, sauf qu'il permet reorderings avec la suite (mais pas la précédente) de la mémoire des actes qui ne sont pas en eux-mêmes imposer la réorganisation des contraintes ordinaires de non-volatile écrit. Entre autres, l'utilisation de contextes, > - lazySet peuvent s'appliquer lors de l'invalide, pour le bien de la collecte des ordures, une référence qui n'est jamais consulté de nouveau.
    • weakCompareAndSet atomiquement lit, et à condition écrit une variable, mais ne crée pas de passe-avant de rangements, de sorte que ne fournit aucune garantie à l'égard de précédents ou suivants les lectures et les écritures de toutes les variables autres que la cible de la weakCompareAndSet.
    • compareAndSet et tous les autres lire-et-opérations de mise à jour comme getAndIncrement ont la mémoire des effets de la lecture et de l'écriture des variables volatiles.

    Maintenant, si vous avez

    volatile AtomicInteger count;

    la volatile partie signifie que chaque thread va utiliser la dernière AtomicInteger de référence, et le fait que c'est un AtomicInteger signifie que vous aurez aussi voir la dernière valeur de cet objet.

    Il n'est pas commun (IME) à besoin de cela - parce que, normalement, vous n'auriez pas réaffecter count pour faire référence à un autre objet. Au lieu de cela, vous auriez:

    private final AtomicInteger count = new AtomicInteger();

    À ce point, le fait que c'est un final variable signifie que tous les threads traitant du même objet - et le fait que c'est un Atomic* objet signifie qu'ils vont voir la dernière valeur à l'intérieur de cet objet.

    • Ok, j'ai modifié la question un petit peu, peut-u s'il vous plaît expliquer si cela allait tenir bon?
    • Pourquoi voudriez-vous utiliser intValue() plutôt que get?
    • Rite, mon erreur, ont mis à jour la première question à get()
    • Merci une tonne.C'est exactement ce que je cherchais
    • Le champ réel maintien de la valeur dans un AtomicInteger est, sans surprise, les volatiles!
    InformationsquelleAutor Jon Skeet
  2. 3

    Je dirais que non, ce n'est pas thread-safe, si vous définissez "thread-safe" comme ayant le même résultat sous un seul mode arborescent et multithread mode. En mono-thread mode, le comte, ne sera jamais plus grand que 10, mais en mode multithread il peut.

    Le problème est que get et incrementAndGet est atomique, mais une if ne l'est pas. Gardez à l'esprit qu'un non-atomique opération peut être interrompue à tout moment. Par exemple:

    1. count = 9 actuellement.
    2. Un Thread s'exécute if(count.get() <10) et obtient true et s'est arrêtée là.
    3. Thread B if(count.get() <10) et obtient true trop pour qu'il fonctionne count.incrementAndGet() et de finitions. Maintenant count = 10.
    4. Fil d'Un curriculum vitae et exécute count.incrementAndGet(), maintenant count = 11 qui ne se produira jamais en single thread mode.

    Si vous voulez faire de ce "thread-safe" sans l'aide de synchronized qui est plus lent, essayez cette mise en place:

    class A{

final AtomicInteger count;

void someMethod(){
//do something
  if(count.getAndIncrement() <10){
      //safe now
  } else count.getAndDecrement(); //rollback so this thread did nothing to count
}
    InformationsquelleAutor Mygod
  3. 1

    Réponse est là, dans ce code,

    http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/atomic/AtomicInteger.java

    C'est le code source de AtomicInteger.
    La valeur est Volatile.
    Donc,AtomicInteger utilise Volatile à l'intérieur.

    InformationsquelleAutor NishantM
  4. 1

    De conserver l'original de la sémantique, et le soutien de plusieurs threads, vous pourriez faire quelque chose comme:

    public class A {

    private AtomicInteger count = new AtomicInteger(0);

    public void someMethod() {

        int i = count.get();
        while (i < 10 && !count.compareAndSet(i, i + 1)) {
            i = count.get();
        }

    }

}

    Cela évite de n'importe quel thread jamais voir le comte atteindre 10.

    InformationsquelleAutor Roger Beardsworth