En el trabajo de hoy, me encontré con la volatilepalabra clave en Java. Al no estar muy familiarizado con esto, encontré esta explicación:
Dado el detalle en el que ese artículo explica la palabra clave en cuestión, ¿alguna vez la usó o podría ver un caso en el que podría usar esta palabra clave de la manera correcta?
Respuestas:
volatiletiene semántica para visibilidad de memoria. Básicamente, el valor de un volatilecampo se vuelve visible para todos los lectores (otros hilos en particular) después de que se completa una operación de escritura. Sin ellos volatile, los lectores podrían ver algún valor no actualizado.
Para responder a su pregunta: Sí, uso una volatilevariable para controlar si algún código continúa un bucle. El bucle prueba el volatilevalor y continúa si es así true. La condición se puede establecer falsellamando a un método de "detención". El bucle ve falsey termina cuando prueba el valor después de que el método de detención completa la ejecución.
El libro " Concurrencia de Java en la práctica ", que recomiendo encarecidamente, ofrece una buena explicación volatile. Este libro está escrito por la misma persona que escribió el artículo de IBM al que se hace referencia en la pregunta (de hecho, cita su libro al final de ese artículo). Mi uso de volatilees lo que su artículo llama la "bandera de estado del patrón 1".
Si desea obtener más información acerca de cómo volatilefunciona bajo el capó, lea sobre el modelo de memoria Java . Si desea ir más allá de ese nivel, consulte un buen libro de arquitectura de computadoras como Hennessy & Patterson y lea sobre la coherencia y coherencia de la memoria caché.
"... el modificador volátil garantiza que cualquier hilo que lea un campo verá el valor escrito más recientemente". - Josh Bloch
Si está pensando en usar volatile, lea el paquete java.util.concurrentque trata sobre el comportamiento atómico.
La publicación de Wikipedia sobre un patrón Singleton muestra un uso volátil.
volatiley synchronizedpalabras clave?
volatileejemplo. Se puede encontrar en una versión archivada .
voidy publicpalabras clave".
Punto importante sobre volatile:
synchronizedy volatiley cerraduras.synchronizedvariables. El uso de synchronizedpalabras clave con una variable es ilegal y generará un error de compilación. En lugar de usar la synchronizedvariable en Java, puede usar la volatilevariable java , que le indicará a los subprocesos JVM que lean el valor de la volatilevariable de la memoria principal y no la almacenen en caché localmente.volatilepalabra clave.Ejemplo de uso de volatile:
public class Singleton {
private static volatile Singleton _instance; // volatile variable
public static Singleton getInstance() {
if (_instance == null) {
synchronized (Singleton.class) {
if (_instance == null)
_instance = new Singleton();
}
}
return _instance;
}
}Estamos creando instancia perezosamente en el momento en que llega la primera solicitud.
Si no hacemos la _instancevariable, volatileentonces el subproceso que está creando la instancia Singletonno puede comunicarse con el otro subproceso. Entonces, si el subproceso A está creando una instancia de Singleton y justo después de la creación, la CPU se corrompe, etc., todos los demás subprocesos no podrán ver el valor de _instanceno nulo y creerán que todavía se le asigna nulo.
¿Por qué pasó esto? Debido a que los hilos del lector no están bloqueándose y hasta que el hilo del escritor salga de un bloque sincronizado, la memoria no se sincronizará y el valor de _instanceno se actualizará en la memoria principal. Con la palabra clave Volátil en Java, esto es manejado por el propio Java y dichas actualizaciones serán visibles por todos los hilos lectores.
Conclusión : la
volatilepalabra clave también se usa para comunicar el contenido de la memoria entre hilos.
Ejemplo de uso de sin volátil:
public class Singleton{
private static Singleton _instance; //without volatile variable
public static Singleton getInstance(){
if(_instance == null){
synchronized(Singleton.class){
if(_instance == null) _instance = new Singleton();
}
}
return _instance;
}El código anterior no es seguro para subprocesos. Aunque verifica el valor de la instancia una vez más dentro del bloque sincronizado (por razones de rendimiento), el compilador JIT puede reorganizar el código de bytes de manera que la referencia a la instancia se establezca antes de que el constructor haya terminado su ejecución. Esto significa que el método getInstance () devuelve un objeto que puede no haberse inicializado por completo. Para que el código sea seguro para subprocesos, la palabra clave volátil se puede usar desde Java 5 para la variable de instancia. Las variables que están marcadas como volátiles solo son visibles para otros hilos una vez que el constructor del objeto ha finalizado su ejecución por completo.
Fuente
volatileuso en Java :
Los iteradores de falla rápida generalmente se implementan utilizando un volatilecontador en el objeto de la lista.
Iteratorse crea un, el valor actual del contador se incrusta en el Iteratorobjeto.Iteratorse realiza una operación, el método compara los dos valores de contador y arroja un ConcurrentModificationExceptionsi son diferentes.La implementación de iteradores a prueba de fallos suele ser ligera. Por lo general, dependen de las propiedades de las estructuras de datos de la implementación de la lista específica. No hay un patrón general.
private static final Singleton _instance;también.
volatile Es muy útil para detener hilos.
No es que deba escribir sus propios hilos, Java 1.6 tiene muchos grupos de hilos agradables. Pero si está seguro de que necesita un hilo, necesitará saber cómo detenerlo.
El patrón que uso para hilos es:
public class Foo extends Thread {
private volatile boolean close = false;
public void run() {
while(!close) {
// do work
}
}
public void close() {
close = true;
// interrupt here if needed
}
}En el segmento de código anterior, la lectura del hilo closeen el bucle while es diferente de la que llama close(). Sin volátil, es posible que el subproceso que ejecuta el bucle nunca vea el cambio para cerrar.
Observe cómo no hay necesidad de sincronización
volatilepalabra clave, y siempre parece funcionar bien.
Un ejemplo común para usar volatilees usar una volatile booleanvariable como una bandera para terminar un hilo. Si ha comenzado un hilo, y desea poder interrumpirlo de manera segura desde un hilo diferente, puede hacer que el hilo verifique periódicamente una bandera. Para detenerlo, establezca la bandera en verdadero. Al hacer el indicador volatile, puede asegurarse de que el subproceso que lo está comprobando verá que se ha establecido la próxima vez que lo verifique sin tener que usar un synchronizedbloque.
Una variable declarada con volatilepalabra clave, tiene dos cualidades principales que la hacen especial.
Si tenemos una variable volátil, ningún hilo puede almacenarla en la memoria caché de la computadora (microprocesador). El acceso siempre ocurrió desde la memoria principal.
Si hay una operación de escritura en una variable volátil, y de repente se solicita una operación de lectura , se garantiza que la operación de escritura finalizará antes de la operación de lectura .
Dos cualidades anteriores deducen que
Y por otro lado,
volatilepalabra clave es una forma ideal de mantener una variable compartida que tiene 'n' número de hilos de lectura y solo un hilo de escritor para acceder a ella. Una vez que agreguemos la volatilepalabra clave, ya está. No hay otros gastos generales sobre la seguridad del hilo.Por el contrario,
No podemos hacer uso de la volatilepalabra clave únicamente, para satisfacer una variable compartida que tiene más de un hilo de escritor que accede a ella .
Nadie ha mencionado el tratamiento de la operación de lectura y escritura para el tipo variable largo y doble. Las lecturas y escrituras son operaciones atómicas para variables de referencia y para la mayoría de las variables primitivas, excepto los tipos de variables largas y dobles, que deben usar la palabra clave volátil para ser operaciones atómicas. @enlace
Sí, debe usarse volátil siempre que desee que varios subprocesos accedan a una variable mutable. No es un caso de uso muy común porque, por lo general, debe realizar más de una operación atómica (por ejemplo, verificar el estado variable antes de modificarlo), en cuyo caso utilizaría un bloque sincronizado.
En mi opinión, dos escenarios importantes además de detener el hilo en el que se usa la palabra clave volátil son:
Deberá usar una palabra clave 'volátil' o 'sincronizada' y cualquier otra herramienta y técnica de control de concurrencia que pueda tener a su disposición si está desarrollando una aplicación multiproceso. Ejemplo de dicha aplicación son las aplicaciones de escritorio.
Si está desarrollando una aplicación que se implementaría en el servidor de aplicaciones (Tomcat, JBoss AS, Glassfish, etc.), no tiene que manejar el control de concurrencia usted mismo, ya que el servidor de aplicaciones ya lo ha abordado. De hecho, si recordaba correctamente, el estándar Java EE prohíbe cualquier control de concurrencia en servlets y EJB, ya que es parte de la capa de 'infraestructura' que se supone que está libre de manejar. Solo realiza el control de concurrencia en dicha aplicación si implementa objetos singleton. Esto incluso ya se solucionó si teje sus componentes usando frameworkd como Spring.
Por lo tanto, en la mayoría de los casos de desarrollo de Java donde la aplicación es una aplicación web y usa el marco de trabajo IoC como Spring o EJB, no necesitaría usar 'volátil'.
volatilesolo garantiza que todos los hilos, incluso ellos mismos, estén incrementándose. Por ejemplo: un contador ve la misma cara de la variable al mismo tiempo. No se usa en lugar de sincronizado o atómico u otras cosas, sincroniza completamente las lecturas. No lo compare con otras palabras clave de Java. Como el ejemplo muestra a continuación, las operaciones de variables volátiles también son atómicas, fallan o tienen éxito a la vez.
package io.netty.example.telnet;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static volatile int a = 0;
public static void main(String args[]) throws InterruptedException{
List<Thread> list = new ArrayList<Thread>();
for(int i = 0 ; i<11 ;i++){
list.add(new Pojo());
}
for (Thread thread : list) {
thread.start();
}
Thread.sleep(20000);
System.out.println(a);
}
}
class Pojo extends Thread{
int a = 10001;
public void run() {
while(a-->0){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Main.a++;
System.out.println("a = "+Main.a);
}
}
}Incluso si pones resultados volátiles o no, siempre serán diferentes. Pero si usa AtomicInteger como se muestra a continuación, los resultados serán siempre los mismos. Esto es lo mismo con sincronizado también.
package io.netty.example.telnet;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
public class Main {
public static volatile AtomicInteger a = new AtomicInteger(0);
public static void main(String args[]) throws InterruptedException{
List<Thread> list = new ArrayList<Thread>();
for(int i = 0 ; i<11 ;i++){
list.add(new Pojo());
}
for (Thread thread : list) {
thread.start();
}
Thread.sleep(20000);
System.out.println(a.get());
}
}
class Pojo extends Thread{
int a = 10001;
public void run() {
while(a-->0){
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
Main.a.incrementAndGet();
System.out.println("a = "+Main.a);
}
}
}Sí, lo uso bastante, puede ser muy útil para código multiproceso. El artículo al que apuntaste es bueno. Aunque hay dos cosas importantes a tener en cuenta:
Absolutamente sí. (Y no solo en Java, sino también en C #). Hay momentos en los que necesita obtener o establecer un valor que garantice que sea una operación atómica en su plataforma dada, un int o booleano, por ejemplo, pero no requiere la sobrecarga de bloqueo de hilo. La palabra clave volátil le permite asegurarse de que cuando lea el valor obtenga el valor actual y no un valor almacenado en caché que acaba de quedar obsoleto por una escritura en otro hilo.
Hay dos usos diferentes de la palabra clave volátil.
Impide que JVM lea valores en el registro y obliga a que su valor se lea desde la memoria.
Se utiliza un indicador de ocupado para evitar que un subproceso continúe mientras el dispositivo está ocupado y el indicador no está protegido por un bloqueo:
while (busy) {
/* do something else */
}El hilo de prueba continuará cuando otro hilo apague la bandera de ocupado :
busy = 0;Sin embargo, dado que se accede con frecuencia a ocupado en el subproceso de prueba, la JVM puede optimizar la prueba colocando el valor de ocupado en un registro, luego probar el contenido del registro sin leer el valor de ocupado en la memoria antes de cada prueba. El subproceso de prueba nunca vería un cambio ocupado y el otro subproceso solo cambiaría el valor de ocupado en la memoria, lo que da como resultado un punto muerto. Declarar el indicador de ocupado como volátil obliga a leer su valor antes de cada prueba.
Reduce el riesgo de errores de consistencia de memoria.
El uso de variables volátiles reduce el riesgo de errores de consistencia de la memoria , porque cualquier escritura en una variable volátil establece una relación de "sucede antes" con lecturas posteriores de esa misma variable. Esto significa que los cambios en una variable volátil siempre son visibles para otros subprocesos.
La técnica de lectura, escritura sin errores de consistencia de memoria se llama acción atómica .
Una acción atómica es aquella que efectivamente ocurre de una vez. Una acción atómica no puede detenerse en el medio: sucede completamente o no sucede en absoluto. No se ven los efectos secundarios de una acción atómica hasta que se complete la acción.
A continuación hay acciones que puede especificar que son atómicas:
¡Salud!
volatiledice para un programador que el valor siempre estará actualizado. El problema es que el valor se puede guardar en diferentes tipos de memoria de hardware. Por ejemplo, pueden ser registros de CPU, caché de CPU, RAM ... Los registros de CPU y caché de CPU pertenecen a la CPU y no pueden compartir datos a diferencia de la RAM que está en el rescate en un entorno de subprocesos múltiples.
volatileLa palabra clave dice que una variable será leída y escrita directamente desde / hacia la memoria RAM . Tiene alguna huella de cálculo
Java 5extendido volatileapoyando happens-before[Acerca de]
Se produce una escritura en un campo volátil, antes de cada lectura posterior de ese campo.
volatileLa palabra clave no cura una race conditionsituación en la que varios hilos pueden escribir algunos valores simultáneamente. La respuesta es la synchronizedpalabra clave [Acerca de]
Como resultado, es seguro solo cuando un hilo escribe y otros simplemente leen el volatilevalor
Volátil hace lo siguiente.
1> La lectura y escritura de variables volátiles por diferentes subprocesos siempre se realiza desde la memoria, no desde la propia caché o registro de la CPU. Por lo tanto, cada hilo siempre trata con el último valor. 2> Cuando 2 subprocesos diferentes funcionan con la misma instancia o variables estáticas en el montón, uno puede ver las acciones de otros como fuera de orden. Vea el blog de jeremy manson sobre esto. Pero la volatilidad ayuda aquí.
El siguiente código en ejecución completa muestra cómo se pueden ejecutar varios subprocesos en un orden predefinido y resultados de impresión sin usar palabras clave sincronizadas.
thread 0 prints 0
thread 1 prints 1
thread 2 prints 2
thread 3 prints 3
thread 0 prints 0
thread 1 prints 1
thread 2 prints 2
thread 3 prints 3
thread 0 prints 0
thread 1 prints 1
thread 2 prints 2
thread 3 prints 3Para lograr esto, podemos usar el siguiente código de ejecución completo.
public class Solution {
static volatile int counter = 0;
static int print = 0;
public static void main(String[] args) {
// TODO Auto-generated method stub
Thread[] ths = new Thread[4];
for (int i = 0; i < ths.length; i++) {
ths[i] = new Thread(new MyRunnable(i, ths.length));
ths[i].start();
}
}
static class MyRunnable implements Runnable {
final int thID;
final int total;
public MyRunnable(int id, int total) {
thID = id;
this.total = total;
}
@Override
public void run() {
// TODO Auto-generated method stub
while (true) {
if (thID == counter) {
System.out.println("thread " + thID + " prints " + print);
print++;
if (print == total)
print = 0;
counter++;
if (counter == total)
counter = 0;
} else {
try {
Thread.sleep(30);
} catch (InterruptedException e) {
// log it
}
}
}
}
}
}El siguiente enlace de github tiene un archivo Léame, que proporciona una explicación adecuada. https://github.com/sankar4git/volatile_thread_ordering
Desde la página de documentación de Oracle , surge la necesidad de variables volátiles para solucionar problemas de consistencia de memoria:
El uso de variables volátiles reduce el riesgo de errores de consistencia de la memoria, ya que cualquier escritura en una variable volátil establece una relación de suceder antes con lecturas posteriores de esa misma variable.
Esto significa que los cambios en una volatilevariable siempre son visibles para otros subprocesos. También significa que cuando un hilo lee una variable volátil, ve no solo el último cambio en el volatile, sino también los efectos secundarios del código que provocó el cambio.
Como se explicó en la Peter Parkerrespuesta, en ausencia de un volatilemodificador, la pila de cada subproceso puede tener su propia copia de la variable. Al hacer la variable comovolatile , se han solucionado los problemas de consistencia de memoria.
Eche un vistazo a la página del tutorial de jenkov para una mejor comprensión.
Eche un vistazo a la pregunta SE relacionada para obtener más detalles sobre volátiles y casos de uso para usar volátiles:
Diferencia entre volátil y sincronizado en Java
Un caso de uso práctico:
Usted tiene muchos hilos, que necesitan imprimir la hora actual en un formato determinado, por ejemplo: java.text.SimpleDateFormat("HH-mm-ss"). Yon puede tener una clase, que convierte la hora actual SimpleDateFormaty actualiza la variable por cada segundo. Todos los otros hilos pueden simplemente usar esta variable volátil para imprimir la hora actual en archivos de registro.
Las variables volátiles son sincronización ligera. Cuando la visibilidad de los últimos datos entre todos los subprocesos es un requisito y la atomicidad puede verse comprometida, en tales situaciones se deben preferir las variables volátiles. La lectura de variables volátiles siempre devuelve la escritura más reciente realizada por cualquier subproceso ya que no se almacenan en caché en registros ni en cachés donde otros procesadores no pueden ver. Volátil es sin bloqueo. Yo uso volátil, cuando el escenario cumple con los criterios mencionados anteriormente.
La tecla volátil cuando se usa con una variable, se asegurará de que los hilos que lean esta variable vean el mismo valor. Ahora, si tiene varios hilos que leen y escriben en una variable, hacer que la variable sea volátil no será suficiente y los datos se corromperán. Los subprocesos de imagen han leído el mismo valor, pero cada uno ha realizado algunos cambios (por ejemplo, incrementó un contador), al volver a escribir en la memoria, se viola la integridad de los datos. Es por eso que es necesario sincronizar la variable (son posibles diferentes formas)
Si los cambios se realizan con 1 subproceso y los demás solo necesitan leer este valor, el volátil será adecuado.
La variable volátil se usa básicamente para la actualización instantánea (vaciado) en la línea principal de caché compartida una vez que se actualiza, para que los cambios se reflejen en todos los subprocesos de trabajo de inmediato.
A continuación se muestra un código muy simple para demostrar el requisito de volatilevariable que se utiliza para controlar la ejecución de Thread desde otro thread (este es un escenario donde volatilese requiere).
// Code to prove importance of 'volatile' when state of one thread is being mutated from another thread.
// Try running this class with and without 'volatile' for 'state' property of Task class.
public class VolatileTest {
public static void main(String[] a) throws Exception {
Task task = new Task();
new Thread(task).start();
Thread.sleep(500);
long stoppedOn = System.nanoTime();
task.stop(); // -----> do this to stop the thread
System.out.println("Stopping on: " + stoppedOn);
}
}
class Task implements Runnable {
// Try running with and without 'volatile' here
private volatile boolean state = true;
private int i = 0;
public void stop() {
state = false;
}
@Override
public void run() {
while(state) {
i++;
}
System.out.println(i + "> Stopped on: " + System.nanoTime());
}
}
Cuando volatileno se usa: nunca verá el mensaje ' Detenido el: xxx ' incluso después de ' Detener el: xxx ', y el programa continúa ejecutándose.
Stopping on: 1895303906650500Cuando se volatileusa: verá el mensaje ' Detenido el: xxx ' inmediatamente.
Stopping on: 1895285647980000
324565439> Stopped on: 1895285648087300Demostración: https://repl.it/repls/SilverAgonizingObjectcode
volatileque vino con el nuevo modelo de memoria Java definido en JSR 133: que cuando un hilo lee unavolatilevariable, ve no solo el último valor escrito por otro hilo, sino también todos los otros escritos en otras variables que eran visibles en ese otro hilo en el momento de lavolatileescritura. Vea esta respuesta y esta referencia .