Java comparte una variable entre dos hilos

Question

Tengo dos hilos. Uno invoca el método de actualización de una clase que modifica una variable. Otro invoca el método de actualización de una clase que lee la variable. Solo un hilo escribe y uno (o más) hilos lee esa variable. ¿Qué debo hacer en términos de concurrencia, ya que soy nuevo en 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... 
    } 
} 

Gracias,

Answer 1

Si hay un único hilo que escribe en variable, puede salirse con la suya haciéndolo volatile. De lo contrario, vea la respuesta con AtomicInteger.

Solo volatile funcionará en el caso de un solo hilo de escritura porque solo hay un hilo de escritura por lo que siempre tiene el valor correcto de variable.

Answer 2

No sólo debe ser variablevolatile, pero también se desea proteger su función update con some sort of synchronization desde ++variable no es una llamada atómica. Es, después de todo, simplemente azúcar sintáctica para

variable = variable + 1; 

que no es atómico.

También debe ajustar cualquier llamada que lea la variable en un lock de algún tipo.

Como alternativa, utilice AtomicInteger. Fue hecho para este tipo de cosas (solo para operaciones enteras).

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... 
    } 
} 

Para los algoritmos más complejos, como asume su edición reciente, use sincronización o bloqueos.

Answer 3

En este caso usaría AtomicInteger, sin embargo, la respuesta generalizada es que el acceso a la variable debe estar protegido por un bloque sincronizado o mediante el uso de otra parte del paquete java.util.concurrent.

Un par de ejemplos:

Uso sincronizados

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); 
     } 
    } 
} 

Usando 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

Uso AtomicInteger o synchronize el acceso a estar a salvo.