Este artículo analiza el uso de subprocesos múltiples volátiles y sincronizados en Java con ejemplos. Compártelo con todos para tu referencia. El método de implementación específico es el siguiente:
Copie el código de la siguiente manera: paquete com.chzhao;
clase pública Volatiletest extiende Thread {
recuento de int estático privado = 0;
ejecución pública vacía() {
contar++;
}
público estático vacío principal (String [] argumentos) {
Hilos de hilo[] = nuevo hilo[10000];
for (int i = 0; i < hilos.longitud; i++) {
hilos[i] = nuevo Volatiletest();
}
for (int i = 0; i < hilos.longitud; i++) {
hilos[i].start();
}
intentar {
Hilo.dormir(1000);
} captura (Excepción interrumpida e) {
e.printStackTrace();
}
System.out.println(recuento);
}
}
El código es el anterior. El resultado esperado es 10000. Sin embargo, dado que count++ no es seguro para subprocesos, el resultado suele ser inferior a 10000.
Para solucionar este problema, se agregó la palabra clave volátil.
Copie el código de la siguiente manera: paquete com.chzhao;
clase pública Volatiletest extiende Thread {
recuento de int estático volátil privado = 0;
ejecución pública vacía() {
contar++;
}
público estático vacío principal (String [] argumentos) {
Hilos de hilo[] = nuevo hilo[10000];
for (int i = 0; i < hilos.longitud; i++) {
hilos[i] = nuevo Volatiletest();
}
for (int i = 0; i < hilos.longitud; i++) {
hilos[i].start();
}
intentar {
Hilo.sleep(2000);
} captura (Excepción interrumpida e) {
e.printStackTrace();
}
System.out.println(recuento);
}
}
Después de la modificación, a menudo se generan valores distintos de 10000.
Modifíquelo a forma sincronizada, el código es el siguiente:
Copie el código de la siguiente manera: paquete com.chzhao;
clase pública SynchronizedTest extiende Thread {
recuento de int estático privado = 0;
ejecución pública vacía() {
sincronizado (LockClass.lock) {
contar++;
}
}
público estático vacío principal (String [] argumentos) {
Hilos de hilo[] = nuevo hilo[10000];
for (int i = 0; i < hilos.longitud; i++) {
hilos[i] = nueva PruebaSincronizada();
}
for (int i = 0; i < hilos.longitud; i++) {
hilos[i].start();
}
intentar {
Hilo.sleep(2000);
} captura (Excepción interrumpida e) {
e.printStackTrace();
}
System.out.println(recuento);
}
}
Copie el código de la siguiente manera: paquete com.chzhao;
clase pública LockClass {
bloqueo de byte estático público [] = nuevo byte [0];
}
Después de esta modificación, la salida es 10000.
¿Significa esto que la palabra clave volátil es completamente inútil? ¿Solo sincronizado puede garantizar la seguridad del hilo?
ilustrar:
El lenguaje Java contiene dos mecanismos de sincronización inherentes: bloques (o métodos) sincronizados y variables volátiles. Ambos mecanismos se proponen para lograr la seguridad de los subprocesos del código. Las variables volátiles están menos sincronizadas (pero a veces son más simples y menos costosas) y su uso también es más propenso a errores. Las variables volátiles en el lenguaje Java pueden considerarse "menos sincronizadas"; en comparación con los bloques sincronizados, las variables volátiles requieren menos codificación y tienen menos sobrecarga de tiempo de ejecución, pero pueden lograr La funcionalidad es solo una parte de la sincronización.
En otras palabras, en algunos casos, volitile es más conveniente de usar que sincronizado, pero, por supuesto, la sincronización es peor.
Espero que este artículo sea útil para la programación Java de todos.