Este artigo analisa o uso de multithreading volátil e sincronizado em Java com exemplos. Compartilhe com todos para sua referência. O método de implementação específico é o seguinte:
Copie o código da seguinte forma: package com.chzhao;
classe pública Volatiletest estende Thread {
contagem interna estática privada = 0;
execução void pública() {
contar++;
}
public static void main(String[] args) {
Tópico threads[] = new Tópico[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
for (int i = 0; i < threads.length; i++) {
tópicos[i].start();
}
tentar {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(contagem);
}
}
O código é como acima. A saída esperada é 10.000. No entanto, como count++ não é thread-safe, a saída geralmente será menor que 10.000.
Para resolver este problema, a palavra-chave volátil foi adicionada.
Copie o código da seguinte forma: package com.chzhao;
classe pública Volatiletest estende Thread {
contagem int estática privada volátil = 0;
execução void pública() {
contar++;
}
public static void main(String[] args) {
Tópico threads[] = new Tópico[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new Volatiletest();
}
for (int i = 0; i < threads.length; i++) {
tópicos[i].start();
}
tentar {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(contagem);
}
}
Após a modificação, geralmente são gerados valores diferentes de 10.000.
Modifique-o para a forma sincronizada, o código é o seguinte:
Copie o código da seguinte forma: package com.chzhao;
classe pública SynchronizedTest estende Thread {
contagem interna estática privada = 0;
execução void pública() {
sincronizado (LockClass.lock) {
contar++;
}
}
public static void main(String[] args) {
Tópico threads[] = new Tópico[10000];
for (int i = 0; i < threads.length; i++) {
threads[i] = new SynchronizedTest();
}
for (int i = 0; i < threads.length; i++) {
tópicos[i].start();
}
tentar {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(contagem);
}
}
Copie o código da seguinte forma: package com.chzhao;
classe pública LockClass {
byte estático público[] bloqueio = novo byte[0];
}
Após esta modificação, a saída é 10.000.
Isso significa que a palavra-chave volátil é completamente inútil? Somente sincronizado pode garantir a segurança do thread?
ilustrar:
A linguagem Java contém dois mecanismos de sincronização inerentes: blocos (ou métodos) sincronizados e variáveis voláteis. Ambos os mecanismos são propostos para alcançar a segurança do thread de código. Variáveis voláteis são menos sincronizadas (mas às vezes mais simples e menos dispendiosas) e seu uso também é mais sujeito a erros. Variáveis voláteis na linguagem Java podem ser consideradas "menos sincronizadas" em comparação com blocos sincronizados, variáveis voláteis requerem menos codificação e têm menos sobrecarga de tempo de execução, mas podem alcançar A funcionalidade é apenas parte da sincronização.
Em outras palavras, em alguns casos, o volítil é mais conveniente de usar do que o sincronizado, mas é claro que a sincronização é pior.
Espero que este artigo seja útil para a programação Java de todos.