Sincronização de campo não final

Um aviso é exibido toda vez que eu sincronizo em um campo de classe não final. Aqui está o código:

public class X  
{  
   private Object o;  

   public void setO(Object o)  
   {  
     this.o = o;  
   }  

   public void x()  
   {  
     synchronized (o) // synchronization on a non-final field  
     {  
     }  
   }  
 } 

então mudei a codificação da seguinte maneira:

 public class X  
 {  

   private final Object o;       
   public X()
   {  
     o = new Object();  
   }  

   public void x()  
   {  
     synchronized (o)
     {  
     }  
   }  
 }  

Não tenho certeza se o código acima é a maneira correta de sincronizar em um campo de classe não final. Como posso sincronizar um campo não final?

Em primeiro lugar, eu encorajo você a realmente tentar lidar com problemas de simultaneidade em um nível mais alto de abstração, ou seja, resolvendo-o usando classes de java.util.concurrent como ExecutorServices, Callables, Futures etc.

Dito isso, não há nada de errado em sincronizar em um campo não final em si. Você só precisa ter em mente que, se a referência do objeto mudar, a mesma seção de código pode ser executada em paralelo . Ou seja, se um thread executa o código no bloco sincronizado e alguém chama setO(...), outro thread pode executar o mesmo bloco sincronizado na mesma instância simultaneamente.

Sincronize no objeto ao qual você precisa de acesso exclusivo (ou, melhor ainda, um objeto dedicado a protegê-lo).

Não é realmente uma boa idéia - porque seus blocos sincronizados não são mais realmente sincronizada de uma forma consistente.

Supondo que os blocos sincronizados garantam que apenas um thread acesse alguns dados compartilhados por vez, considere:

• O thread 1 entra no bloco sincronizado. Sim - tem acesso exclusivo aos dados compartilhados ...
• O thread 2 chama setO ()
• Thread 3 (ou ainda 2 ...) entra no bloco sincronizado. Eek! Ele acha que tem acesso exclusivo aos dados compartilhados, mas o thread 1 ainda está lidando com isso ...

Por que você quer que isso aconteça? Talvez haja algumas situações muito especializadas em que faça sentido ... mas você teria que me apresentar um caso de uso específico (junto com maneiras de mitigar o tipo de cenário que apresentei acima) antes de eu ficar feliz com isto.

Concordo com um dos comentários de John: Você deve sempre usar um dummy de bloqueio final ao acessar uma variável não final para evitar inconsistências no caso de alterações de referência da variável. Portanto, em qualquer caso e como primeira regra prática:

Regra # 1: Se um campo não for final, sempre use um modelo de bloqueio final (privado).

Razão # 1: você mantém o bloqueio e altera a referência da variável por conta própria. Outro thread esperando fora do bloqueio sincronizado poderá entrar no bloco protegido.

Razão # 2: você mantém o bloqueio e outro thread altera a referência da variável. O resultado é o mesmo: outro thread pode entrar no bloco protegido.

Mas, ao usar um boneco de bloqueio final, há outro problema : você pode obter dados errados, porque seu objeto não final só será sincronizado com a RAM ao chamar synchronize (objeto). Portanto, como uma segunda regra prática:

Regra # 2: Ao bloquear um objeto não final, você sempre precisa fazer as duas coisas: Usar um manequim de bloqueio final e o bloqueio do objeto não final para o bem da sincronização de RAM. (A única alternativa será declarar todos os campos do objeto como voláteis!)

Esses bloqueios também são chamados de "bloqueios aninhados". Observe que você deve chamá-los sempre na mesma ordem, caso contrário, você obterá um bloqueio morto :

public class X {
    private final LOCK;
    private Object o;

    public void setO(Object o){
        this.o = o;  
    }  

    public void x() {
        synchronized (LOCK) {
        synchronized(o){
            //do something with o...
        }
        }  
    }  
} 

Como você pode ver, escrevo os dois cadeados diretamente na mesma linha, porque eles sempre pertencem um ao outro. Assim, você pode até fazer 10 bloqueios de aninhamento:

synchronized (LOCK1) {
synchronized (LOCK2) {
synchronized (LOCK3) {
synchronized (LOCK4) {
    //entering the locked space
}
}
}
}

Observe que este código não será quebrado se você apenas adquirir um bloqueio interno como synchronized (LOCK3)por outras threads. Mas ele vai quebrar se você chamar em outro tópico algo como este:

synchronized (LOCK4) {
synchronized (LOCK1) {  //dead lock!
synchronized (LOCK3) {
synchronized (LOCK2) {
    //will never enter here...
}
}
}
}

Há apenas uma solução alternativa para esses bloqueios aninhados ao lidar com campos não finais:

Regra # 2 - Alternativa: Declare todos os campos do objeto como voláteis. (Não vou falar aqui sobre as desvantagens de fazer isso, por exemplo, evitar qualquer armazenamento em caches de nível x, mesmo para leituras, também.)

Portanto, aioobe está certa: basta usar java.util.concurrent. Ou comece a entender tudo sobre sincronização e faça você mesmo com bloqueios aninhados. ;)

Para obter mais detalhes por que a sincronização em campos não finais quebras, dê uma olhada em meu caso de teste: https://stackoverflow.com/a/21460055/2012947

E para obter mais detalhes por que você precisa sincronizar tudo devido à RAM e aos caches, dê uma olhada aqui: https://stackoverflow.com/a/21409975/2012947

Na verdade, não estou vendo a resposta correta aqui, ou seja, está tudo bem fazer isso.

Eu nem sei por que é um aviso, não há nada de errado com isso. A JVM garante que você obtenha algum objeto válido de volta (ou nulo) ao ler um valor, e você pode sincronizar em qualquer objeto.

Se você planeja realmente alterar o bloqueio enquanto ele está em uso (ao invés de, por exemplo, alterá-lo de um método init, antes de começar a usá-lo), você deve criar a variável que planeja alterar volatile. Então, tudo o que você precisa fazer é sincronizar tanto no objeto antigo quanto no novo, e você pode alterar o valor com segurança

public volatile Object lock;

...

synchronized (lock) {
    synchronized (newObject) {
        lock = newObject;
    }
}

Lá. Não é complicado, escrever código com bloqueios (mutexes) é realmente muito fácil. Escrever código sem eles (código de bloqueio gratuito) é o que é difícil.

EDITAR: Portanto, esta solução (como sugerido por Jon Skeet) pode ter um problema com a atomicidade da implementação de "synchronized (object) {}" enquanto a referência do objeto está mudando. Eu perguntei separadamente e de acordo com o Sr. Erickson não é thread-safe - veja: A entrada em bloco sincronizado é atômica? . Portanto, tome como exemplo de como NÃO fazê-lo - com links por quê;)

Veja o código como funcionaria se synchronized () fosse atômico:

public class Main {
    static class Config{
        char a='0';
        char b='0';
        public void log(){
            synchronized(this){
                System.out.println(""+a+","+b);
            }
        }
    }

    static Config cfg = new Config();

    static class Doer extends Thread {
        char id;

        Doer(char id) {
            this.id = id;
        }

        public void mySleep(long ms){
            try{Thread.sleep(ms);}catch(Exception ex){ex.printStackTrace();}
        }

        public void run() {
            System.out.println("Doer "+id+" beg");
            if(id == 'X'){
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(1000);
                    // do not forget to put synchronize(cfg) over setting new cfg - otherwise following will happend
                    // here it would be modifying different cfg (cos Y will change it).
                    // Another problem would be that new cfg would be in parallel modified by Z cos synchronized is applied on new object
                    cfg.b=id;
                }
            }
            if(id == 'Y'){
                mySleep(333);
                synchronized(cfg) // comment this and you will see inconsistency in log - if you keep it I think all is ok
                {
                    cfg = new Config();  // introduce new configuration
                    // be aware - don't expect here to be synchronized on new cfg!
                    // Z might already get a lock
                }
            }
            if(id == 'Z'){
                mySleep(666);
                synchronized (cfg){
                    cfg.a=id;
                    mySleep(100);
                    cfg.b=id;
                }
            }
            System.out.println("Doer "+id+" end");
            cfg.log();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Doer X = new Doer('X');
        Doer Y = new Doer('Y');
        Doer Z = new Doer('Z');
        X.start();
        Y.start();
        Z.start();
    }

}

AtomicReference se adapta às suas necessidades.

Da documentação java sobre o pacote atômico :

Um pequeno kit de ferramentas de classes que oferece suporte à programação de thread-safe sem bloqueio em variáveis ​​únicas. Em essência, as classes neste pacote estendem a noção de valores voláteis, campos e elementos de matriz para aqueles que também fornecem uma operação de atualização condicional atômica da forma:

boolean compareAndSet(expectedValue, updateValue);

Código de amostra:

String initialReference = "value 1";

AtomicReference<String> someRef =
    new AtomicReference<String>(initialReference);

String newReference = "value 2";
boolean exchanged = someRef.compareAndSet(initialReference, newReference);
System.out.println("exchanged: " + exchanged);

No exemplo acima, você substitui Stringpelo seu próprioObject

Pergunta relacionada de SE:

Quando usar AtomicReference em Java?

Se onunca mudar durante o tempo de vida de uma instância de X, a segunda versão é o melhor estilo, independentemente de a sincronização estar envolvida.

Agora, se há algo errado com a primeira versão, é impossível responder sem saber o que mais está acontecendo naquela aula. Eu tenderia a concordar com o compilador que ele parece sujeito a erros (não vou repetir o que os outros disseram).

Apenas adicionando meus dois centavos: recebi este aviso quando usei um componente que é instanciado pelo designer, então seu campo não pode ser realmente final, porque o construtor não pode usar parâmetros. Em outras palavras, eu tinha um campo quase final sem a palavra-chave final.

Acho que é por isso que é apenas um aviso: provavelmente você está fazendo algo errado, mas pode estar certo também.