Java partage une variable entre deux threads

Question

J'ai deux threads. On invoque la méthode de mise à jour d'une classe qui modifie une variable. Un autre appelle la méthode de mise à jour d'une classe qui lit la variable. Un seul thread écrit et un (ou plusieurs) threads lisent cette variable. Que dois-je faire en termes de concurrence, étant donné que je suis novice en matière de multi-threading?

public class A 
{ 
    public int variable; // Does this need to be volatile? 
     // Not only int, could also be boolean or float. 
    public void update() 
    { 
     // Called by one thread constantly 
     ++variable; 
     // Or some other algorithm 
     variable = complexAlgorithm(); 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     // I don't care about missing an update 
     int v = a.variable; 
     // Do algorithm with v... 
    } 
} 

Merci,

Answer 1

S'il y a un seul et unique thread qui écrit à variable, vous pouvez vous en sortir en le faisant volatile. Sinon, voir la réponse avec AtomicInteger.

Seul volatile fonctionnera dans le cas d'un seul thread d'écriture car il n'y a qu'un seul thread d'écriture, donc il a toujours la bonne valeur de variable.

Answer 2

Non seulement devrait être variablevolatile, mais vous voulez aussi protéger votre fonction update avec some sort of synchronization depuis ++variable n'est pas un appel atomique. Il s'agit, après tout, de sucre syntaxique pour

variable = variable + 1; 

qui n'est pas atomique.

Vous devriez également inclure tous les appels qui lisent une variable dans un lock.

Vous pouvez également utiliser un AtomicInteger. Il a été fait pour ce genre de chose (pour des opérations entières).

public class A 
{ 
    // initially had said volatile wouldn't affect this variable because 
    // it is not a primitive, but see correction in comments 
    public final AtomicInteger variable; // see comments on this issue of why final 
    public void update() 
    { 
     // Called by one thread constantly 
     variable.getAndIncrement(); // atomically adds one 
    } 
    public int retrieveValue() 
    { 
     return variable.get(); // gets the current int value safely 
    } 
} 

public class B 
{ 
    public A a; 
    public void update() 
    { 
     // Called by another thread constantly 
     int v = a.retrieveValue(); 
     // Do algorithm with v... 
    } 
} 

Pour les algorithmes plus complexes, comme le suppose votre modification récente, utilisez la synchronisation ou les verrous.

Answer 3

Dans ce cas j'utiliserais un AtomicInteger, cependant la réponse généralisée est que l'accès à la variable devrait être protégé par un bloc synchronisé, ou en utilisant une autre partie du paquetage java.util.concurrent.

Quelques exemples:

Utilisation synchronisée

public class A { 
    public final Object variable; 
    public void update() { 
     synchronized(variable) { 
      variable.complexAlgorithm(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     sychronized(a.variable) { 
      consume(a.variable); 
     } 
    } 
} 

En utilisant java.util.concurrent

public class A { 
    public final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); 
    public final Object variable; 
    public void update() { 
     lock.writeLock().lock(); 
     try { 
      variable.complexAlgorithm(); 
     } finally { 
      lock.writeLock().unlock(); 
     } 
    } 
} 

public class B { 
    public A a; 
    public void update() { 
     a.lock.readLock().lock(); 
     try { 
      consume(a.variable); 
     } finally { 
      a.lock.readLock().unlock(); 
     } 
    } 
} 

Answer 4

Utilisez AtomicInteger ou synchronize l'accès à l'abri.