Problèmes d'attribution Java - Est-ce atomique?

Question

J'ai quelques questions sur l'assigment de Java.

• Cordes

J'ai une classe:

public class Test { 
private String s; 

public synchronized void setS(String str){ 
    s = s + " - " + str; 
} 

public String getS(){ 
    return s; 
} 
} 

J'utilise "synchronisé" dans mon setter, et en évitant dans mon getter, parce que dans mon application, il y a des tonnes de données, et très peu de paramètres. Les paramètres doivent être synchronisés pour éviter les incohérences. Ma question est: est d'obtenir et de définir une variable atomique? Je veux dire, dans un environnement multithread, Thread1 est sur le point de définir des variables, tandis que Thread2 est sur le point d'obtenir "s". Est-il possible que la méthode getter puisse avoir quelque chose de différent de l'ancienne valeur de s ou de la nouvelle valeur de s (supposons que nous ayons seulement deux threads)? Dans mon application, il n'est pas un problème pour obtenir la nouvelle valeur, et ce n'est pas un problème pour obtenir l'ancien. Mais pourrais-je avoir autre chose?

• Et qu'en est-il de HashMap?

considérant ceci:

public class Test { 
     private Map<Integer, String> map = Collections.synchronizedMap(new HashMap<Integer, String>()); 

     public synchronized void setMapElement(Integer key, String value){ 
     map.put(key, value); 
     } 

     public String getValue(Integer key){ 
     return map.get(key); 
     } 
} 

met et obtenir atomique? Comment HashMap gère-t-il l'insertion d'un élément? Est-ce qu'il supprime d'abord l'ancienne valeur et met le maintenant? Pourrais-je avoir autre chose que l'ancienne valeur ou la nouvelle valeur?

Merci d'avance!

Answer 1

Dans le premier cas, String s'avère être sûr pour une publication non sécurisée (dans le "nouveau" Java Memory Model (JMM)), donc c'est correct.

N'étant pas volatile il y a théoriquement quelque problème à ne pas avoir une valeur à jour, mais alors la signification de mise à jour n'est pas claire. Vous pouvez remplacer le verrou par une boucle CAS (compare-sand-swap), mais cela ne vous donnera probablement pas beaucoup de gain de performance, que le verrou soit susceptible d'être contesté ou non.

Dans le cas de HashMap, une carte non synchronisée n'est pas sûre à lire s'il y a une autre écriture de thread, même un seul thread d'écriture. En fait, cela s'est avéré conduire à des boucles infinies sur les systèmes de production exécutant des logiciels populaires. Le code de la question utilise deux verrous pour la carte, ce qui est supérieur (bien que vous ayez besoin d'un maintien explicite du même verrou si vous utilisez un itérateur). Le fait de ne pas être final empêche la classe conteneur d'être sûre pour une publication non sécurisée. Si map était volatile et vous avez créé une nouvelle carte pour chaque put, alors cela pourrait être fait pour être sûr sans synchronisation sur le get.

Answer 2

Plutôt que d'encapsuler votre HashMap dans quelque chose pour le synchroniser, pensez plutôt à utiliser un java.util.concurrency.ConcurrentHashMap.

Ceci est une version mise à jour de HashMap qui garantit que les "Retrievals reflètent les résultats des dernières opérations de mise à jour terminées dès leur apparition.".

Answer 3

Les réponses précédentes sont correctes en indiquant qu'avec les nouvelles machines JVM (1.5+), la version String est sans danger, en ce qui concerne la corruption de données. Et vous semblez être conscient de l'accès non synchronisé à la baisse; celui des changements n'étant pas nécessairement visible via les getters.

Cependant: question plus utile est la suivante: y a-t-il une raison de synchronisation ici? Si c'est juste pour être intéressé à savoir cela, c'est bien. Mais pour le code réel, la règle générale des lectures et écritures est que s'il y a les deux, les deux devraient être synchronisés. Donc, bien que vous puissiez dans ce cas omettre la synchronisation (ce qui signifie potentiellement que les threads ne voient pas les changements que font les autres threads), il semble y avoir peu d'avantages à le faire.

Answer 4

Dans un environnement multithread vous devrez synchroniser le getter afin de vous assurer que le client voit la valeur la plus à jour de s.

Answer 5

Peut-être qu'un Read Write Lock pourrait résoudre votre problème?

Jetez un oeil à sa documentation:

Un verrou en lecture-écriture permet un plus grand niveau de l'accès aux données concurrency partagées que celle permise par un verrou d'exclusion mutuelle. Il exploite le fait que si un seul thread à la fois (un thread d'écriture) peut modifier les données partagées, dans un grand nombre de cas, un nombre quelconque de threads peut lire simultanément les données (donc les threads de lecture). En théorie, l'augmentation de la concurrence permise par l'utilisation d'un verrou en lecture-écriture conduira à des améliorations de performance par rapport à l'utilisation d'un verrou d'exclusion mutuelle.