Qual melhor usar ou "quando usar" qual e por que? volatile int x = 0; x++; ou int x = 0; synchronized int plus() { return x++; } ou ainda int x = 0; synchronized(x) { x++…

Synchronized ou volatile?

Qual melhor usar ou “quando usar” qual e por que?

volatile int x = 0;
x++;

int x = 0;
synchronized int plus&#40;&#41; &#123;
    return x++;
&#125;

ou ainda

int x = 0;
synchronized&#40;x&#41; &#123;
    x++;
&#125;

O que me dizem?

Eu usaria o volatile pelo que acabo de aprender dele (vide topico sobre obscuridade), apesar do volatile não ser totalmente suportado por todas as JVM’s…

Pelo que aprendi até agora, todas as soluções funcionariam, mas:

Sincronizar o método parece mais lento, afinal voce está tendo o overhead de sincronizacao + o de chamada de método…
Sincronizar a variavel parece viável, apesar de sujar bastante o código (imagina um monte de sincronização no código, fica horrível)…

Criar a variável como volatile parece o mais interessante, já que ela é automaticamente “sincronizada”, pois todas as operações nela ficam atômicas…

Pesquisei um pouco, e pra quem não souber aqui vai o que achei:

Google:

“Atomic” normalmente se refere a uma ação. Ação é algo que causa uma mudança de estado em um objeto. Uma ação faz com que um objeto (pode ser uma variável, instancia, banco de dados etc) mudar de um estado inicial para um estado final.
Algumas ações podem precisar de mais que um passo para ser completada. Cada passo deixa o objeto em um estado intermediário enquanto que o passo final é o que determina o estado final do objeto.
Fazer uma ação atomicamente significa que ou a ação terá sucesso ou falhará (tendo todos os passos completos e o objeto no estado final ou nenhum dos passos completos e deixando o objeto no estado inicial).

Exemplo de incrementação de variável:
i++;
O código acima é um simples comando. O objeto é a variável “i” e as ações são “incremente o valor de i em 1”. No entanto, mesmo sendo apenas um simples comando, ele pode ser decomposto nos seguintes passos:

Carrega o valor de “i” da memória reservada dele em um registro.

Incrementa o valor de “i” no registro em 1.

Armazena o novo valor na área de memória reservada para ele.

Fazer a ação acima atomicamente significa que nada mais afetando o valor de “i” possa acontecer enquanto qualquer um dos passos está ainda em execução. É óbvio que tendo 2 ou mais threads acessando paralelamente o o comando i++ pode levar a alguns incrementos serem perdidos:

Thread 1: Carrega “i” da memória para um registro.
(troca de contexto - salva os registros)
Thread 2: Carrega “i” da memória para um registro.
Thread 2: Incrementa o registro.
Thread 2: Salva o registro para a memória.
(troca de contexto - restaura os registros)
Thread 1: Incrementa o registro.
Thread 1: Salve o registro na memória (sobrescrevendo o valor previamente escrito pela Thread 2)

Para que esse comando simples seja executado atomicamente, voce precisa garantir que nenhuma outra thread que tenha acesso a variavel “i”, use o CPU enquanto a thread está incrementando o valor de “i”.

A natureza atomica das ações pode ficar ainda mais óbvia em banco de dados. Em banco de dados, multiplos select/insert/update precisam ser executados como parte de uma simples transacao (deixando as tabelas involvidas em um estado intermediario até que a ultima operação seja feita) e enquanto isso nenhum outro comando deve ser executado nas tabelas/linhas sendo afetadas.

É essa aí a descrição de uma operação atômica, que é o que o synchronized e volatile fazem.

E ai, o que dizem sobre as opcoes?

“matheus”:
e tem como pegar o lock de um tipo primitivo? :roll:

int x = 0; synchronized(x) { x++; }

Que eu saiba não hehe, mas foi só pra ilustrar o exemplo

Nesse caso pior ainda né, afinal teoricamente se voce tiver MUITAS threads, pode acontecer de perder operações no valor.

Pelo que aprendi hoje (continuei lendo mais umas 2h), muita coisa não é como deveria ser hehe

Cada thread obtem copias locais, quando uma thread atualiza, ela atualiza a cópia dela e depois propaga pra memoria principal ou seja, mais uma possibilidade de falhar, no caso das copias nao estarem totalmente sincronizadas entre si…

Acho que pra ter certeza mesmo só testando, algo como:

Cria 2048 threads, cada uma faz um “i++” em uma variavel global, de modo que cada uma faça sei lá, 100.000.000 de incrementos…

Se no final o resultado não for

2.048.000.000, então teve problema de “skipping” mesmo…

De fato, vou testar isso mais tarde se lembrar!

2 Respostas

Topicos relacionados