Les objets immuables sont thread safe, mais pourquoi?

Si un thread est la création de remplissage de la variable de référence de l'immuable de la classe par la création de son objet et à la deuxième fois de l'autre thread coups de pied avant de le premier thread se termine et crée un autre objet de l'immuable de la classe, ne sont pas immuables de la classe de l'utilisation de thread dangereux?
La création d'un objet immuable dit aussi que tous les champs marqués d'aussi définitif que..... "il peut être nécessaire pour s'assurer du bon comportement si une référence à une instance nouvellement créée est transmis à partir d'un thread à l'autre sans synchronisation"
Sont-ils en train de dire que l'autre thread peut re-point de la variable de référence à un autre objet de l'immuable, de classe et de cette façon, le fils sera pointant vers différents objets de quitter l'état incompatible?

source d'informationauteur Taran Singh

java

8

Des objets immuables sont thread-safe, mais pourquoi?

Immuable objet est un objet qui n'est plus modifié une fois qu'il a été construit. Si, en plus, l'immuable objet est seulement rendue accessible à d'autres thread après il a été construit, et cela se fait à l'aide de la synchronisation, tous les threads de voir le même état valide de l'objet.

Si un thread est la création de remplissage de la variable de référence de l'immuable de la classe par la création de son objet et à la deuxième fois de l'autre thread coups de pied avant de le premier thread se termine et crée un autre objet de l'immuable de la classe, ne sont pas immuables de la classe de l'utilisation de thread dangereux?

Pas. Ce qui vous fait penser? Un objet thread de sécurité est totalement épargnée par ce que vous faites à d'autres objets de la même classe.

Sont-ils en train de dire que l'autre thread peut re-point de la variable de référence à un autre objet de l'immuable, de classe et de cette façon, le fils sera pointant vers différents objets de quitter l'état incompatible?

Ils sont en train de dire que chaque fois que vous passez quelque chose à partir d'un thread à l'autre, même si c'est juste une référence à un objet immuable, vous devez synchroniser les threads. (Par exemple, si vous passez par la référence à partir d'un thread à l'autre en les stockant dans un objet ou un champ statique, que l'objet ou le domaine est accessible par plusieurs threads, et doit être thread-safe)
5

En plus d'autres réponses postées déjà, des objets immuables, une fois créés, ils ne peuvent pas être modifiée. Par conséquent, ils sont essentiellement en lecture seule.

Et comme nous le savons tous, en lecture seule, les choses sont toujours thread-safe. Même dans des bases de données, de multiples requêtes peut lire les mêmes lignes en même temps, mais si vous voulez modifier quelque chose, vous devez verrou exclusif.
5

Fil de sécurité est le partage de données de sécurité, Et parce que dans votre code vous de prendre des décisions fondées sur les données de vos objets, de l'intégrité et de comportement déterministe de c'est vital. j'.e

Imaginer que nous avons partagé booléen variable d'instance entre deux threads qui sont sur le point d'exécuter une méthode avec la logique suivante
- Si l'indicateur est faux, alors j'ai l'impression de "faux" et puis j'ai mis le drapeau de retour pour de vrai.
- Si l'indicateur est vrai, alors j'ai l'impression de "vrai" et puis j'ai mis le drapeau dos à faux.
Si vous exécutez en permanence dans une seule boucle de fil, vous aurez un déterministe de sortie qui ressemble à:

faux - vrai - faux - vrai - faux - vrai - faux ...

Mais, si vous avez exécuté le même code avec les deux fils, puis, à la sortie de votre sortie n'est pas déterministe de plus, la raison en est que le fil d'Une réveil de, la lecture de l'indicateur, voir ce qui est faux, mais avant de pouvoir faire quoi que ce soit, le fil B se réveille et lit le drapeau, ce qui est également faux!! Ainsi, les deux seront d'impression de faux... Et ce n'est qu'un scénario qui pose problème je pense... Comme vous pouvez le voir, ce qui est mauvais.

Si vous prenez les mises à jour de l'équation le problème a disparu, juste parce que vous êtes l'élimination de tous les risques associés à la synchronisation des données. c'est pourquoi nous disons que des objets immuables sont thread-safe.

Il est important de noter cependant, que des objets immuables sont pas toujours la solution, vous pouvez avoir un cas de données que vous devez partager entre de différents fils, dans ce cas, il existe de nombreuses techniques qui vont au-delà de la simple synchronisation et qui peut faire beaucoup de différence dans les performances de votre application, mais c'est un autre sujet.

Des objets immuables sont importantes afin de garantir que les zones de l'application que nous sommes sûrs que n'avez pas besoin d'être mis à jour, ne sont pas mis à jour, de sorte que nous savons pour sûr que nous n'allons pas avoir le multithreading questions

Probablement, vous pourriez être intéressés à prendre un coup d'oeil à un couple de livres:

C'est le plus populaire: http://www.amazon.co.uk/Java-Concurrency-Practice-Brian-Goetz/dp/0321349601/ref=sr_1_1?ie=UTF8&qid=1329352696&sr=8-1

Mais personnellement, je préfère celui-ci: http://www.amazon.co.uk/Concurrency-State-Models-Java-Programs/dp/0470093552/ref=sr_1_3?ie=UTF8&qid=1329352696&sr=8-3

Être conscient que le multithreading est probablement la plus délicate de l'aspect de n'importe quelle application!
4

En fait des objets immuables sont toujours thread-safe, mais ses références peuvent ne pas l'être.

Confus?? vous ne devriez pas être:-

Pour en revenir à base:
Thread-safe signifie simplement que deux ou plusieurs threads doivent travailler en coordination sur le partage des ressources ou de l'objet. Ils ne devraient pas l'emporter sur les changements fait par un autre thread.

Maintenant String est immuable la classe, à chaque fois qu'un thread essaie de le changer, il suffit simplement de créer un nouvel objet. Donc, même simplement le même thread ne peut pas apporter des modifications à l'objet original, & de parler de l'autre thread serait comme aller au Soleil mais le hic ici est que, généralement, nous utilisons la même vieille référence au point que l'objet nouvellement créé.

Quand nous faisons de code, nous, évaluer tout changement dans l'objet la référence seulement.

Déclaration 1:
String str = "123"; //au départ de la chaîne partagé à deux fils

Déclaration 2:
str = str+"FirstThread"; //pour être exécuté par un thread

Énoncé 3:
str=str+"SecondThread"; //pour être exécuté par le thread de deux

Maintenant, étant donné qu'il n'y a pas de synchronisation, volatils ou en finale des mots-clés à dire compilateur de sauter en utilisant son intelligence à des fins d'optimisation (toute réorganisation ou la mise en cache des choses), ce code peut être exécuté de la manière suivante.
1. Charge Statement2, ainsi str = "123"+"FirstThread"
2. Charge Statement3, ainsi str = "123"+"SecondThread"
3. Magasin Statement3, ainsi str = "123SecondThread"
4. Magasin Statement2, ainsi str = "123FirstThread"
et enfin la valeur de référence str="123FirstThread" et pendant un certain temps, si nous supposons que heureusement, notre GC thread est en sommeil, que nos objets immuables existent encore intacte dans notre chaîne de piscine.

Donc, des objets Immuables sont toujours thread-safe, mais leurs références peuvent ne pas l'être. Pour faire leurs références "thread-safe", on peut avoir besoin d'y accéder à partir de blocs synchronisés/méthodes.
0

Deux threads ne sera pas la création d'un même objet, donc pas de problème là.

En ce qui concerne 'il peut être nécessaire de s'assurer...', ce qu'ils disent, c'est que si vous NE faites PAS tous les domaines final, vous aurez à assurer le bon comportement de vous-même.

Immutabilité ne signifie pas la sécurité des threads.En ce sens, la référence à un objet immuable peuvent être modifiées, même après qu'il est créé.

//No setters provided
class ImmutableValue
{

     private final int value = 0;

     public ImmutableValue(int value)
     {
          this.value = value;
     }

     public int getValue()
     {
          return value;
     }
}

public class ImmutableValueUser{
  private ImmutableValue currentValue = null;//currentValue reference can be changed even after the referred underlying ImmutableValue object has been constructed.

  public ImmutableValue getValue(){
    return currentValue;
  }

  public void setValue(ImmutableValue newValue){
    this.currentValue = newValue;
  }

}

-3

Immutabilité ne fait pas garantir la sécurité des threads ,si les threads sont juste accéder à des objets immuables pour lire alors que vous n'avez pas à prendre des précautions supplémentaires pour s'assurer que les données sont cohérentes,mais si les threads peuvent manipuler des données, alors vous devez utiliser une méthode sûre pour partager des données entre les threads, de sorte que chaque thread voit données cohérentes.

Vous devez vous connecter pour publier un commentaire.