Muitos amigos podem ter ouvido falar da palavra -chave volátil e podem ter usado. Antes do Java 5, era uma palavra -chave controversa, pois usá -la em programas geralmente resultou em resultados inesperados. Somente depois que o Java 5 a palavra -chave volátil recuperou sua vitalidade.
A função da palavra -chave volátil é tornar todos os threads no sistema compartilhar visíveis para as variáveis modificadas pela palavra -chave e pode proibir a memória de trabalho do Thread de variáveis em cache modificadas pelo volátil.
Cenários de uso voláteis 2:
1. Visibilidade: Java fornece palavras -chave voláteis para garantir a visibilidade.
Quando uma variável compartilhada é modificada por volátil, garante que o valor modificado seja atualizado para a memória principal imediatamente e, quando outros threads precisarem lê -lo, ele lerá o novo valor na memória.
No entanto, variáveis compartilhadas comuns não podem garantir visibilidade, porque é incerto quando a variável compartilhada normal é gravada na memória principal após a modificação. Quando outros threads o leem, o valor antigo original ainda pode estar na memória; portanto, a visibilidade não pode ser garantida.
Além disso, sincronizado e bloqueio também podem garantir a visibilidade. O sincronizado e o bloqueio podem garantir que apenas um thread adquira o bloqueio ao mesmo tempo e execute o código de sincronização. Antes de liberar o bloqueio, a modificação da variável será atualizada na memória principal. Portanto, a visibilidade pode ser garantida.
Vejamos primeiro um pedaço de código. Se o thread 1 for executado primeiro e o thread 2 for executado posteriormente:
// Thread 1Boolean Stop = false; while (! Stop) {Dosomething ();} // Thread 2Stop = true;Este código é uma parte de código muito típica, e muitas pessoas podem usar esse método de marcação ao interromper threads. Mas, de fato, esse código será executado completamente corretamente? O tópico será interrompido? Não necessariamente. Talvez na maioria das vezes, esse código possa interromper os threads, mas também pode fazer com que o thread não seja interrompido (embora essa possibilidade seja muito pequena, uma vez que isso acontecer, isso causará um loop morto).
Vamos explicar por que esse código pode fazer com que o thread não interrompa. Conforme explicado anteriormente, cada encadeamento tem sua própria memória de trabalho durante a operação; portanto, quando o Thread 1 estiver em execução, ele copiará o valor da variável de parada e o colocará em sua própria memória de trabalho.
Então, quando o thread 2 altera o valor da variável de parada, mas não teve tempo de escrevê -lo na memória principal, o Thread 2 vai fazer outras coisas, então o thread 1 não sabe sobre as alterações do Thread 2 na variável de parada, para que continue a fazer o loop.
Mas depois de modificar com volátil, torna -se diferente:
Primeiro: o uso da palavra -chave volátil forçará o valor modificado a ser gravado na memória principal imediatamente;
Segundo: se você usar a palavra -chave volátil, quando o Thread 2 a modificar, a linha de cache da variável de cache parou na memória de trabalho do Thread 1 será inválida (se for refletida na camada de hardware, a linha de cache correspondente no cache L1 ou L2 da CPU é inválida);
Terceiro: Como a linha de cache da variável de cache Stop na memória de trabalho do Thread 1 é inválida, o Thread 1 o lerá na memória principal quando lê o valor da parada variável novamente.
Então, quando o Thread 2 modifica o valor de parada (é claro, existem 2 operações aqui, modificando o valor na memória de trabalho do Thread 2 e, em seguida, escrevendo o valor modificado na memória), a linha de cache da variável de cache parada na memória de trabalho do Thread 1 será inválida. Quando o Thread 1 lê, ele descobre que sua linha de cache é inválida. Ele aguardará a atualização do endereço de memória principal correspondente da linha de cache e leia o valor mais recente na memória principal correspondente.
Então, o que o Thread 1 lê é o valor correto mais recente.
2. Garanta a ordem
booleano volátil iniciado = false; // Thread 1: context = loadContext (); iniciado = true; // Thread 2: while (! Inited) {sleep ()} doSomethingWithConfig (contexto);Verifique se o contexto foi inicializado.
3. Verifique
classe singleton {private volátil estático singleton instância = null; private singleton () {} public static singleton getInstance () {if (instance == null) {synchronized (singleton.class) {if (instance == null) = new singleton ();}}};O exposto acima é uma explicação detalhada do papel e do uso da palavra -chave volátil em Java apresentada a você pelo editor. Espero que seja útil para você. Se você tiver alguma dúvida, deixe -me uma mensagem e o editor responderá a você a tempo. Muito obrigado pelo seu apoio ao site wulin.com!