ViniGodoy wrote:o sincronismo é feito em this. Então, se duas threads forem disparadas por objetos diferentes, o que acontece? Você tem dois "this" diferentes (cada um de um objeto), mas uma única variável x, já que ela é estática.

TiagoTC wrote:E. Declaring the doThings() method as static would make the class thread-safe.

ViniGodoy wrote:Esse exemplo mostra porque coisas synchronized são uma péssima escolha quando o assunto é thread safety.

O que acontece quando o trecho é sincronizado, mas não estático? Duas threads, rodando paralelamente, poderão acessar aquele trecho de código ao mesmo tempo, em objetos diferentes. Porém, ambas estarão compartilhando a variável x.

A solução para isso é que ambas as threads compartilhem o monitor. Para fazer isso, você declara o método como static (que fará com que compartilhem o monitor TesteSeven.class). Ou, no interior do método faz

public void doThings(){ synchronized (x) { int current = x; current++; x = current; } }
Para que ambas compartilhem x.


Uma última alternativa seria criar um lock externo, e fazer com que as threads o compartilhem:

public class TestSeven extends Thread { private int[] lock; private static int x; public TestSeven(int[] lock) { this.lock = lock; } public synchronized void doThings(){ int current = x; current++; x = current; } public void run(){ doThings(); } }

Isso seria usado assim:
int[] lock = new lock[0]; TestSeven one = new TestSeven(lock); TestSeven two = new TestSeven(lock);


Agora, não entendi o que você quer dizer com "sincronize a variável x". O que é sincronizado é a área de código, não variáveis. A sincronização faz com que duas threads não possam acessar o mesmo trecho de código do mesmo objeto ao mesmo tempo.

Ponto V wrote:
Java Concurrency in Practice, do Brian Goetz: Um dos melhores livros sobre multi-threading e Java, escrito por ninguém menos do que o criador da linguagem.