Pourquoi est i++ pas atomique?

Pourquoi est i++ pas atomique en Java?

Pour obtenir un peu plus profondément en Java, j'ai essayé de compter combien de fois la boucle dans les threads sont exécutées.

J'ai donc utilisé une

private static int total = 0;

dans la classe principale.

J'ai deux fils.

  • Thread 1: Imprime System.out.println("Hello from Thread 1!");
  • Filetage 2: Imprime System.out.println("Hello from Thread 2!");

Et je compte les lignes imprimées en 1 fil et du fil 2. Mais les lignes de fil 1 + lignes de fil 2 ne correspondent pas au nombre total de lignes imprimées.

Voici mon code:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Test {
private static int total = 0;
private static int countT1 = 0;
private static int countT2 = 0;
private boolean run = true;
public Test() {
ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
newCachedThreadPool.execute(t1);
newCachedThreadPool.execute(t2);
try {
Thread.sleep(1000);
}
catch (InterruptedException ex) {
Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
}
run = false;
try {
Thread.sleep(1000);
}
catch (InterruptedException ex) {
Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println((countT1 + countT2 + " == " + total));
}
private Runnable t1 = new Runnable() {
@Override
public void run() {
while (run) {
total++;
countT1++;
System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
}
}
};
private Runnable t2 = new Runnable() {
@Override
public void run() {
while (run) {
total++;
countT2++;
System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
}
}
};
public static void main(String[] args) {
new Test();
}
}
  • Pourquoi n'essayez-vous pas avec AtomicInteger?
  • Voir aussi: l'autre DONC, la question, ++ pas considéré atomique, Simultanéité en Java.
  • pourquoi dites-vous AtomicInteger n'est pas atomique? Vous pouvez utiliser la getAndIncrement la méthode pour ce faire. Il est atomique.
  • la JVM a un iinc opération d'incrémentation de nombres entiers, mais qui ne fonctionne que pour les variables locales, où la simultanéité n'est pas un sujet de préoccupation. Pour les champs, le compilateur génère de lecture-modification-écriture séparément.
  • Pourquoi voudriez-vous même s'attendre à être atomique?
  • Même sur le matériel qui met en œuvre un "incrémenter emplacement de stockage" de l'enseignement, il n'y a aucune garantie que c'est thread-safe. Tout simplement parce qu'une opération peut être représenté comme un seul opérateur ne dit rien à ce sujet un fil de sécurité.
  • Freak: même si il y avait un iinc instruction pour les champs, ayant une seule instruction ne permet pas de garantir l'atomicité, par exemple, la non-volatile long et double d'accès sur le terrain en ne garantissant pas être atomique, indépendamment du fait qu'elle est effectuée par une seule instruction bytecode.

InformationsquelleAutor Andie2302 | 2014-08-06
  1. 120

    i++ est probablement pas atomique en Java, car l'atomicité est une exigence particulière, qui n'est pas présent dans la majorité des utilisations de i++. Cette exigence a une surcharge importante: il y a un gros coût dans la réalisation d'une opération d'incrémentation atomique; il s'agit d'une synchronisation à la fois le logiciel et le matériel des niveaux qui n'ont pas besoin d'être présent dans une simple incrémentation.

    Vous pourriez faire l'argument que i++ doivent avoir été conçus et documentés comme spécifiquement de l'exécution d'une atomique incrément, de sorte qu'un non-atomique de l'incrément est effectuée à l'aide i = i + 1. Cependant, ce serait briser le "compatibilité culturelle" entre le Java et le C et le C++. Ainsi, il serait enlever une pratique de la notation qui les programmeurs familier avec le C-comme les langages de prendre pour acquis, à qui il donne une signification particulière ne s'applique que dans des circonstances limitées.

    De base code C ou C++ comme for (i = 0; i < LIMIT; i++) serait de traduire en Java comme for (i = 0; i < LIMIT; i = i + 1); car il serait inapproprié d'utiliser la atomique i++. Ce qui est pire, les programmeurs venant de C ou d'autres C-comme les langages Java serait d'utiliser i++ de toute façon, résultant de l'utilisation inutile des instructions atomiques.

    Même à la machine à jeu d'instruction niveau, un type d'incrément de l'opération n'est généralement pas atomique pour des raisons de performances. En x86, une instruction spéciale "préfixe lock" doit être utilisé pour faire de la inc instruction atomique: pour les mêmes raisons que ci-dessus. Si inc ont toujours été atomique, il n'y aurait jamais être utilisé en cas de non-atomique inc est nécessaire; les programmeurs et les compilateurs serait de générer du code qui charge, ajoute 1 et les magasins, car il serait beaucoup plus rapide.

    Dans certains jeu d'instructions architectures, il n'est pas atomique inc ou peut-être pas inc à tous; faire atomique inc sur MIPS, vous devez écrire une boucle du logiciel qui utilise le ll et sc: charge liée, et de les stocker en liberté sous condition. La charge liée lit le mot, et de les stocker en liberté sous condition stocke la nouvelle valeur si le mot n'a pas changé, sinon elle échoue (ce qui est détecté et provoque une ré-essayer).

    • en tant que java n'a pas de pointeurs, incrémenter des variables locales est intrinsèquement thread enregistrer, donc avec des boucles de la problème la plupart du temps ne serait pas si mal. votre point sur moins de surprise tribunes, bien sûr. aussi, comme il est, i = i + 1 serait une traduction pour ++i, pas i++
    • Le premier mot de la question est "pourquoi". A partir de maintenant, c'est la seule réponse à aborder la question du "pourquoi". Les autres réponses vraiment viens de re-état de la question. Donc +1.
    • Il est intéressant de noter qu'une atomicité de garantie ne résoudrait pas la question de la visibilité pour les mises à jour de non-volatile champs. Donc, à moins que vous ne traiter chaque champ implicitement volatile une fois qu'un thread a utilisé le ++ de l'opérateur, par exemple une atomicité de garantie ne résoudrait pas simultanées problèmes de mise à jour. Pourquoi donc potentiellement perdre de performance pour quelque chose si ça ne résout pas le problème.
    • ne pas vous dire ++? 😉
    InformationsquelleAutor Kaz
  2. 33

    i++ implique deux opérations :

    1. lire la valeur actuelle de i
    2. incrément de la valeur et de l'attribuer à i

    Lorsque deux threads effectuer i++ sur la même variable dans le même temps, ils peuvent obtenir la même valeur de courant de i, et puis incrémenter et mis à i+1, de sorte que vous aurez une simple incrémentation au lieu de deux.

    Exemple :

    int i = 5;
Thread 1 : i++;
//reads value 5
Thread 2 : i++;
//reads value 5
Thread 1 : //increments i to 6
Thread 2 : //increments i to 6
//i == 6 instead of 7
    • (Même si i++ est atomique, il ne serait pas bien défini/thread-safe comportement.)
    • +1, mais "1. A, 2. B et C" sonne comme trois, pas deux. 🙂
    • Notez que même si l'opération n'a été mis en œuvre avec une seule instruction machine qui incrémenté d'un emplacement de stockage en place, il n'y a aucune garantie qu'il serait thread-safe. La machine a encore besoin de récupérer la valeur de l'incrément, et de la stocker en arrière, plus il peut y avoir plusieurs cache des copies de l'emplacement de stockage.
    • Pas nécessairement. Si le chercher, l'accroissement et la boutique sont fait de façon atomique, ou dans une "transaction" (sur le CPU level), alors il est probablement thread-safe. Bien que, oui, il peut y avoir des copies mises en cache, mais c'est une autre histoire. Je pense que la seule possible contention serait si l'incrémentation de fil en pause (en raison d'ordonnancement du noyau) avant que l'accroissement de l'opération, ce qui permet éventuellement d'un autre thread pour lire la variable. Je pense que cela dépend de l'enfilage de la mise en œuvre, de l'OS et de l'UC.
    • Si deux processeurs d'exécuter la même opération contre le même emplacement de stockage simultanément, et il n'y a pas de "réserve" diffusée sur l'emplacement, ils vont presque certainement nuire et de produire de faux résultats. Oui, il est possible pour cette opération, pour être "sûr", mais il faut déployer des efforts particuliers, même au niveau du matériel.
    • Mais je pense que la question était "Pourquoi" et pas "Ce qui arrive".
    • J'ai interprété la question différemment, car, si l'op voulait savoir pourquoi java créateurs ont choisi de ne pas faire ++ atomique, il n'y avait pas besoin de tout le code posté. Le code implicite ils ont demandé pourquoi le code se comporte de cette façon. Basé sur la accepté de répondre j'ai peut-être eu tort.
    • Merci à vous; cependant, je crois, que 1) lecture actuelle; 2)incrément; 3) de confier il est de retour encore trois opérations 🙂

    InformationsquelleAutor Eran
  3. 11

    La chose la plus importante est la JLS (Java Language Specification) plutôt que la façon dont les différentes implémentations de la JVM peut ou peut ne pas avoir mis en oeuvre un certain fonction de la langue. Le JLS définit le ++ postfix opérateur dans la clause 15.14.2 qui dit je.un. "la valeur 1 est ajoutée à la valeur de la variable et la somme est stocké dans la variable". Nulle part il n'est mention ou allusion à multithreading ou de l'atomicité. Pour ces JL fournit volatils et synchronisé. En outre, il existe le package java.util.de façon concomitante.atomique (voir http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html)

    InformationsquelleAutor Jonathan Rosenne
  4. 5

    Pourquoi i++ pas atomique en Java?

    Brisons l'opération d'incrémentation en plusieurs états:

    Thread 1 & 2 :

    1. Récupère la valeur du total de la mémoire
    2. Ajouter 1 à la valeur
    3. Écrire de nouveau à la mémoire

    Si il n'y a pas de synchronisation alors disons Thread on a lu la valeur 3 et incrémenté à 4, mais n'a pas écrit, il est revenu. À ce stade, le changement de contexte se produit. Enfiler deux lit la valeur 3, il incrémente et le changement de contexte se produit. Bien que les deux threads ont incrémenté de la valeur totale, il sera toujours 4 - condition de course.

    • Je ne comprends pas comment cela devrait être une réponse à la question. Une langue peut définir n'importe quelle fonction comme atomique, que ce soit par incréments ou les licornes. Vous venez d'illustrer une conséquence de ne pas être atomique.
    • Oui une langue peut définir n'importe quelle fonction comme atomique, mais aussi loin que java est considéré comme l'opérateur d'incrémentation(qui est la question posté par OP) n'est pas atomique et ma réponse en indiquer les raisons.
    • (désolé pour mon ton sévère dans le premier commentaire), Mais alors, la raison semble être: "parce que si il serait atomique, alors il n'y aurait pas de conditions de course". I. e., il semble que si une condition de concurrence est souhaitable.
    • la surcharge introduite afin de garder une augmentation atomique est énorme et rarement désiré, gardant le fonctionnement à bas prix et en conséquence non atomique est souhaitable que la plupart du temps.
    • Notez que je ne remets pas les faits, mais le raisonnement dans cette réponse. Essentiellement, il dit "i++ n'est pas atomique en Java, car les conditions de course, il a", qui est comme de dire que ", une voiture n'a pas d'airbag en raison des incidents qui peuvent se produire" ou "vous n'avez pas de couteau avec votre currywurst-parce que le wurst devrez peut-être couper". Donc, je ne pense pas que c'est une réponse. La question n'est pas de "Ce qui ne i++ faire?" ou "Quelle est la conséquence de i++ n'étant pas synchronisés?".
    InformationsquelleAutor Aniket Thakur
  5. 5

    i++ est un énoncé qui implique de 3 opérations:

    1. Lire la valeur actuelle
    2. Écrire nouvelle valeur
    3. Magasin nouvelle valeur

    Ces trois opérations ne sont pas destinés à être exécutés en une seule étape ou en d'autres termes i++ n'est pas un composé opération. En conséquence, toutes sortes de choses peuvent aller mal lorsque plusieurs threads sont impliqués dans un seul, mais non des composés de l'opération.

    Envisagez le scénario suivant:

    Temps 1:

    Thread A fetches i
Thread B fetches i

    Temps 2:

    Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i
//At this time thread B seems to be more 'active'. Not only does it overwrite 
//its local copy of i but also makes it in time to store -bar- back to 
//'main' memory (i)

    Temps 3:

    Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.
Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

    Et là vous l'avez. Une condition de concurrence.

    C'est pourquoi i++ n'est pas atomique. S'il l'était, rien de tout cela ne serait arrivé et chaque fetch-update-store arriverait atomiquement. C'est exactement ce que AtomicInteger est pour et dans votre cas, il serait sans doute mieux.

    P. S.

    Un excellent livre, à la couverture de toutes ces questions, et puis certains est ceci:
    Java de la Simultanéité dans la Pratique

    • Hmm. Une langue peut définir n'importe quelle fonction comme atomique, que ce soit par incréments ou les licornes. Vous venez d'illustrer une conséquence de ne pas être atomique.
    • Exactement. Mais je signale aussi que ce n'est pas une opération unique qui, par extension, implique que le coût de calcul pour le tournage de plusieurs de ces opérations en atomique est beaucoup plus cher, qui à son tour -en partie - justifie pourquoi i++ n'est pas atomique.
    • Alors que je reçois votre point, votre réponse est un peu déroutant pour l'apprentissage. Je vois un exemple, et une conclusion qui dit que "en raison de la situation dans l'exemple"; à mon humble avis c'est un raisonnement incomplet 🙁
    • Peut-être pas le plus pédagogique de la réponse, mais c'est le mieux que je puisse vous proposons actuellement. J'espère qu'il va aider les gens et de ne pas les confondre. Merci pour critisism cependant. Je vais essayer d'être plus précis dans mes prochains posts.
    InformationsquelleAutor kstratis
  6. 2

    Dans la JVM, une augmentation implique une lecture et une écriture, de sorte qu'il n'est pas atomique.

    InformationsquelleAutor celeritas
  7. 2

    Si l'opération i++ serait atomique, vous n'auriez pas la chance de lire la valeur de celui-ci. C'est exactement ce que vous voulez faire à l'aide de i++ (au lieu d'utiliser ++i).

    Par exemple, regardez le code suivant:

    public static void main(final String[] args) {
int i = 0;
System.out.println(i++);
}

    Dans ce cas, nous nous attendons à la sortie: 0
    (parce que nous post incrémentation, par exemple, de lire d'abord, puis mise à jour)

    C'est l'une des raisons de l'opération ne peut pas être atomique, parce que vous avez besoin de lire la valeur (et en faire quelque chose) et puis mise à jour de la valeur.

    L'autre raison importante est que de faire quelque chose atomiquement généralement prend plus de temps à cause de verrouillage. Il serait ridicule d'avoir toutes les opérations sur les primitives de prendre un peu de temps pour les rares cas où les gens veulent avoir des opérations atomiques. C'est pourquoi ils ont ajouté des AtomicInteger et d'autres atomique de classes à la langue.

    • C'est trompeur. Vous devez vous séparer d'exécution et d'obtenir le résultat, sinon vous risquez de ne pas obtenir les valeurs de aucun opération atomique.
    • Non, il ne l'est pas, c'est pourquoi Java est AtomicInteger a un get(), getAndIncrement(), getAndDecrement(), incrementAndGet(), decrementAndGet (), etc.
    • Et le langage Java pourrait avoir défini i++ être étendu à d' i.getAndIncrement(). Une telle expansion n'est pas nouveau. E. g., les lambdas en C++ sont développés pour anonyme des définitions de classe en C++.
    • Étant donné atomique i++ on peut trivialement créer atomique ++i ou vice-versa. L'un équivaut à l'autre plus un.
    InformationsquelleAutor Roy van Rijn
  8. 2

    Il y a deux étapes:

    1. chercher j'ai de la mémoire
    2. ensemble i+1 pour i

    donc c'est pas une opération atomique.
    Lorsque thread1 exécute i++, et thread2 exécute i++, la valeur finale de j'ai peut-être i+1.

    InformationsquelleAutor yanghaogn
  9. -1

    De la concurrence (le Thread classe et tel) est une fonction ajoutée dans v1.0 de Java. i++ a été ajouté dans la version bêta avant, et en tant que tel il est encore plus probable dans son (plus ou moins) la mise en œuvre d'origine.

    C'est au programmeur de synchroniser les variables. Découvrez Oracle tutoriel sur ce.

    Edit: Pour préciser, j'++ est une procédure bien définie qui est antérieure à Java, et en tant que tel, les concepteurs de Java ont décidé de garder la fonctionnalité d'origine de cette procédure.

    L' ++ opérateur a été défini en B (1969), qui est antérieure à java et le filetage en juste un peu.

    • -1 "public class Thread ... Depuis: JDK1.0" Source: docs.oracle.com/javase/7/docs/api/index.html?java/lang/...
    • La version n'a pas tellement d'importance que le fait qu'il était encore mis en œuvre avant la classe Thread et n'a pas été modifié à cause d'elle, mais j'ai édité ma réponse à vous s'il vous plaît.
    • Ce qui importe, c'est que votre demande "il était encore mis en œuvre avant la classe Thread" n'est pas étayée par les sources. i++ pas être atomique est une décision de conception, pas une surveillance dans un système de culture.
    • Lol c'est mignon. i++ a été défini bien avant de Threads, tout simplement parce qu'il y avait des langues qui existaient avant Java. Les créateurs de Java utilisée ceux d'autres langues comme base au lieu de la redéfinition d'un bien accepté la procédure. Où ai-je jamais dire que c'est un oubli?
    • Voici quelques sources qui montrent comment la vieille ++ est: en.wikipedia.org/wiki/Increment_and_decrement_operators en.wikipedia.org/wiki/B_(programming_language)
    • Juste parce qu'un langage est emprunté ou inspiré par une fonctionnalité correspondante dans d'autres langues ne signifie pas nécessairement conserve exactement les mêmes caractéristiques sous-jacentes. Considérons, par exemple, la variété de lambda fonctions dans différentes langues (par exemple, la faiblesse de Python lambda par rapport à la vraie Lisp lambdas symbo1ics.com/blog/?p=1292). Même en C++, certaines fonctionnalités prises à partir de C ne sont pas tout à fait identiques à leurs C homologues, malgré le fait que le C++ est souvent pensé pour être rétro-compatible avec les C (cprogramming.com/tutorial/c-vs-c++.html).
    • Mais emprunté de nombreux mots-clés et les opérateurs ne sont pas mis en œuvre comme dans la langue/s, ils ont été empruntés. E. g., class et operator. en C++ sont totalement orthogonal à leur Java "équivalents".

    InformationsquelleAutor TheBat