Creo que los lectores que comprendan los subprocesos múltiples de Java conocerán claramente su función. La palabra clave volátil se utiliza para declarar variables de tipo simple, como int, float, boolean y otros tipos de datos. Si estos tipos de datos simples se declaran volátiles, las operaciones sobre ellos se vuelven atómicas. Pero esto tiene ciertas limitaciones. Por ejemplo, n en el siguiente ejemplo no es atómico:
Copie el código de código de la siguiente manera:
paquete de mitos;
clase pública JoinThread extiende Thread
{
público estático volátil int n = 0;
ejecución pública vacía()
{
para (int i = 0; i < 10; i++)
intentar
{
norte = norte + 1;
sleep(3); // Para que los resultados de la ejecución sean más aleatorios, retrasa 3 milisegundos.
}
captura (Excepción e)
{
}
}
public static void main (String[] args) lanza una excepción
{
Hilos de hilo[] = nuevo hilo[100];
para (int i = 0; i < threads.length; i++)
// Crea 100 hilos
hilos[i] = nuevo JoinThread();
para (int i = 0; i < threads.length; i++)
//Ejecuta los 100 hilos recién creados
hilos[i].start();
para (int i = 0; i < threads.length; i++)
//Continuar después de que se hayan ejecutado los 100 subprocesos
hilos[i].join();
System.out.println("n=" + JoinThread.n);
}
}
Si la operación en n es atómica, el resultado de salida final debe ser n=1000. Sin embargo, al ejecutar el código de área anterior, la salida n suele ser menor que 1000, lo que muestra que n=n+1 no es una operación de nivel atómico. . La razón es que para una variable simple declarada volátil, si el valor actual está relacionado con el valor anterior de la variable, entonces la palabra clave volátil no tiene ningún efecto, lo que significa que las siguientes expresiones no son operaciones atómicas:
Copie el código de código de la siguiente manera:
norte = norte + 1;
n++;
Si desea que esta situación sea una operación atómica, debe utilizar la palabra clave sincronizada. El código anterior se puede cambiar al siguiente formato:
Copie el código de código de la siguiente manera:
paquete de mitos;
clase pública JoinThread extiende Thread
{
público estático int n = 0;
público estático sincronizado void inc()
{
n++;
}
ejecución pública vacía()
{
para (int i = 0; i < 10; i++)
intentar
{
inc(); // n = n + 1 cambiado a inc();
sleep(3); // Para que los resultados de la ejecución sean más aleatorios, retrasa 3 milisegundos.
}
captura (Excepción e)
{
}
}
public static void main (String[] args) lanza una excepción
{
Hilos de hilo[] = nuevo hilo[100];
para (int i = 0; i < threads.length; i++)
// Crea 100 hilos
hilos[i] = nuevo JoinThread();
para (int i = 0; i < threads.length; i++)
//Ejecuta los 100 hilos recién creados
hilos[i].start();
para (int i = 0; i < threads.length; i++)
//Continuar después de que se hayan ejecutado los 100 subprocesos
hilos[i].join();
System.out.println("n=" + JoinThread.n);
}
}
El código anterior cambia n=n+1 a inc(), donde el método inc usa la palabra clave sincronizada para la sincronización del método. Por lo tanto, tenga cuidado al usar la palabra clave volátil. No significa que las variables de tipo simple se modifiquen con volátil. Todas las operaciones en esta variable son las operaciones originales cuando el valor de la variable está determinado por el anterior, como n =. n+1, n++, etc., la palabra clave volátil no será válida. La operación en la variable es de nivel atómico solo cuando el valor de la variable no tiene nada que ver con su valor anterior. Por ejemplo, n = m + 1, esto. es el nivel original. Por lo tanto, debe tener cuidado al usar claves volátiles. Si no está seguro, puede usar sincronizadas en lugar de volátiles.