sécurité et immuabilité des threads Java

Une condition de concurrence critique ne se produit que si deux threads accèdent à la même ressource en même temps et qu'un ou plusieurs threads écrivent sur cette ressource. Si plusieurs threads lisent la même ressource, aucune condition de concurrence critique ne se produira.

Nous pouvons être sûrs que les objets partagés entre les threads sont thread-safe en rendant l'objet partagé immuable et non mis à jour par aucun thread. Voici un exemple :

public class ImmutableValue{

  private int value = 0;

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

  public int getValue(){
    return this.value;
  }
}

Remarquez comment la valeur de l'instance ImmutableValue est transmise à ce constructeur. Notez également qu'il n'y a pas de méthode définie ici. Une fois cette instance créée, vous ne pouvez pas modifier sa valeur. C'est immuable. Cependant, vous pouvez utiliser la méthode get pour le lire.

Si vous devez effectuer une opération sur cette instance, vous pouvez renvoyer une nouvelle instance avec la valeur du résultat de l'opération. Voici également un exemple :

public class ImmutableValue{

  private int value = 0;

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

  public int getValue(){
    return this.value;
  }

  
      <strong>public ImmutableValue add(int valueToAdd){
      return new ImmutableValue(this.value + valueToAdd);
      }</strong>
  
}

Notez que la méthode add renvoie une nouvelle instance avec le résultat de l'opération d'ajout, plutôt que d'ajouter la valeur à elle-même .

Cette référence n'est pas thread-safe

Il est important de s'en souvenir, même si un L'objet est immuable et donc thread-safe, les références à cet objet peuvent ne pas être thread-safe. Regardez cet exemple :

public class Calculator{
  private ImmutableValue currentValue = null;

  public ImmutableValue getValue(){
    return currentValue;
  }

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

  public void add(int newValue){
    this.currentValue = this.currentValue.add(newValue);
  }
}

Cette classe Calculatrice contient une référence à l'objet ci-dessus. Notez qu'il peut modifier cette référence via la méthode setValue et la méthode add. Par conséquent, même si cette classe utilise un objet immuable en interne, il n’est pas lui-même immuable et n’est donc pas thread-safe. En d’autres termes : cette classe ImmutableValue est thread-safe, mais son utilisation ne l’est pas. C'est quelque chose à garder à l'esprit lorsque vous essayez d'assurer la sécurité des threads grâce à l'immuabilité.

Pour rendre la classe Calculator thread-safe, vous devez utiliser le mot-clé synchronisé sur les méthodes getValue(), setValue() et add(). Cela fera l'affaire.

Ce qui précède est le contenu de la sécurité et de l'immuabilité des threads Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !