java - ¿Tengo que declarar mi variable de miembro de escucha compartida como volátil?

Question

Tengo una clase simple que hace algunos cálculos en su propio hilo e informa los resultados al oyente.

class Calculator extends Thread { 
    protected Listener listener; 

    public void setListener(Listener l) { 
     listener = l; 
    } 

    public void run() { 
     while (running) { 
      ... do something ... 

      Listener l = listener; 

      if (l != null) { 
       l.onEvent(...); 
      } 
     } 
    } 
} 

En cualquier momento, el usuario puede llamar setListener (nulo) si él no quiere ningún evento para un determinado período de tiempo. Así, en el run() función, se crea una copia del oyente, por lo que no se puede ejecutar en una NullPointerExceptionlo que podría suceder si el oyente se establece en NULL después de la ! = Null comprobación del estado tuvo éxito . En mi caso, creo que esta es una alternativa correcta para sincronizarlo.

Mi pregunta es: ¿debo declarar aquí que la variable del miembro oyente es volátil? He estado leyendo mucho sobre volátil, pero todos los ejemplos parecen enfocarse en los tipos de datos básicos (booleano, int, ...) y no en Objetos. Por lo tanto, no estoy seguro de si los Objetos deberían/​​podrían declararse también volátiles. Creo que tengo que declararlo como volátil, por lo que el hilo siempre tiene la última versión de la variable miembro, pero no estoy seguro.

Gracias!

Answer 1

Sí. Para garantizar que el subproceso Calculator ve un nuevo valor, establecido por otro subproceso, debería hacer que la variable sea volátil.

Sin embargo, volatile es un mecanismo de bajo nivel y rara vez se utiliza en el código de cliente. Le sugiero que considere usar java.util.concurrent.AtomicReference en este escenario, lo que asegura que todo funcione como se espera.

Answer 2

Si utiliza este enfoque, ya no puede garantizar que un oyente no reciba una notificación de evento después de que setListener(null) regresa. Ejecución podría proceder de la siguiente manera:

Listener l = listener; // listener != null at this point 

// setListener(null) executes here 

if (l != null) { 
    l.onEvent(...); 
} 

Si tiene que ser garantizado que no hay eventos serán publicados en un oyente después de que haya sido registrado, entonces es necesario utilizar bloques sincronizados. Declarar listener ser volatile no ayudará. El código en su lugar debe ser:

public synchronized void setListener(Listener l) { 
    listener = l; 
} 

public void run() { 
    while (running) { 
     ... do something ... 

     synchronized (this) { 
      if (listener != null) { 
       listener.onEvent(...); 
      } 
     } 
    } 
} 

Si desea evitar el gasto de synchronized todo el tiempo, usted puede hacer esto:

if (listener != null) { 
    synchronized (this) { 
     if (listener != null) { 
      listener.onEvent(...); 
     } 
    } 
} 

Este corre el riesgo leve que se pierda un evento después configurando un oyente no nulo. Declarar que listener es volatile probablemente lo arreglaría.