La palabra clave volátil juega un papel relativamente importante en Java Multi-Threading. La función principal de volátil es mantener las variables visibles en el hilo múltiple y es el mecanismo de sincronización más ligero proporcionado en Java.
Visibilidad
Todas las variables en el modelo de memoria de Java (las variables aquí son variables globales, no variables locales. No hay ningún problema ausente de subprocesos en el método, porque las variables se destruyen como el método se llama) se almacenan en la memoria principal. Cada hilo tiene su propia memoria de trabajo. Cada vez que se ejecute el subproceso, se obtendrá una copia de la variable de la memoria principal, y la operación de la variable se realizará en la memoria de trabajo del hilo. Los diferentes hilos no pueden compartir la memoria de trabajo, y solo pueden leer la copia de la variable de la memoria principal. Específicamente, se puede expresar en la figura a continuación:
Sin embargo, para las modificaciones volátiles (utilizando sincronizadas/finales, la regla anterior está rota, es decir, cuando el subproceso modifica el valor de la variable, otros subprocesos pueden conocer inmediatamente el cambio de la variable. Sin embargo, para las variables ordinarias, cuando un hilo modifica una variable, es necesario escribir la variable de nuevo a la memoria principal primero, y otros subprocesos serán visibles a la hilo de la variable de la variable. Se puede deducir que mientras se use una variable modificada por Volatile, se garantiza que la variable es segura en un entorno múltiple, porque es visible para la memoria de trabajo de todos los hilos, es decir, consistente, pero muchas operaciones en Java no son atómicas, por lo que el uso de Volatil en algunas operaciones de Java no puede garantizar problemas de seguridad.
Prueba de clase pública {Volátil estático privado t = 0; privado static int add () {return t ++; } public static void testVolatile () {for (int i = 0; i <20; i ++) {Thread Thread = new Thread (()-> {for (int j = 0; j <1000; j ++) {add ();}}); Thread.Start (); } while (Thread.ActiveCount ()> 1) {Thread.yield (); } System.out.println (t); } public static void main (string [] args) {testVolatile (); }}Se espera que el valor T sea de 20,000, pero habrá una situación en la que el valor T es inferior a 20,000. Deberías adivinar la razón. El problema radica en t ++. T ++ no es una operación atómica. En Java, la operación t ++ significa primero para obtener el valor t, luego agregar 1 y luego asignar t. Al obtener el valor t, se modifica por volátil, por lo que se puede obtener el último valor del hilo. Sin embargo, al agregar 1, no se puede garantizar. Es posible que otros hilos ya hayan agregado 1.
Entonces, ¿qué escenario es el más adecuado para usar Volátil?
* En la operación variable no depende del valor actual
* Las variables no necesitan participar en restricciones invariantes con otras variables de estado
Traducido al chino significa que para las variables que han leído y escriben en múltiples hilos, puede usar volátiles para modificarlas. De esta manera, no debe usar operaciones de bloqueo/sincronizado para operaciones de lectura. Leer directamente es porque las variables son visibles.