Primeiro de tudo, vamos eliminar uma confusão comum, que aparentemente você está cometendo.
Existem 2 coisas distintas:
a) A classe Thread, e seus objetos. Nesse caso, representados pela ThreadA. Elas descrevem as threads em execução e disparam novas threads.
b) As threads em execução propriamente ditas. Elas representam os diversos fluxos do programa ou a linha que vc vê avançando sobre o programa, quando usa seu debugger.
Dito isso, que fique claro que a sincronização atua sobre threads e não sobre os objetos da classe Thread. Ou seja, ThreadA, quando recebe um wait(), não faz nada. O objeto não muda de estado, a menos que a thread que tenha rodado esse wait, seja o mesmo que está o objeto da classe ThreadA está representando.
Quem muda de estado é a thread em si, que pode ter sido disparada em qualquer classe que tenha estendido Runnable e sido iniciada com o start() da classe Thread.
Então, veja os passos que todas as threads fazem num código como esse:
public class ThreadA {
public void metodoA() {
synchronized(this) {
wait();
}
}
//mais coisa aqui pra baixo
}
1. Uma thread entra no metodoA();
2. Ela chega no trecho sincronizado. Então, verifica se o monitor (this) está disponível;
3. Se estiver, ela reserva o monitor para si, e entra no trecho sincronizado;
4. Ela encontra o wait(). Põe-se a dormir, e libera o monitor.
E se o monitor não estiver disponível no passo 2? Então:
3 (alternativo). A thread dorme, entrando numa fila até que o monitor esteja disponível;
Quando ocorre um notify, o que acontece?
A primeira thread da fila que está dentro do wait() desperta. Se ela não puder despertar, nada acontece (mesmo que existam outras threads nesse wait, que poderiam despertar, nada acontece).
E quando ocorre um notifyAll()?
A todas as threads da fila que estão dentro do wait() despertam, entretanto, só uma pegará o monitor da área sincronizada de cada vez. Se qualquer uma delas puder despertar, o monitor irá para a primeira que despertar e as demais voltam a dormir.
E o que acontece quando a thread que está na região sincronizada, sai dessa região?
Se houverem threads esperando na entrada do sincronized (this) elas acordam, repetindo o comportamento "equivalente" ao do notifyAll().
Note que estamos falando de threads. Pouco importa em que classe a thread tenha sido originalmente disparada, ou em que classe a thread está. Pense sempre nas linhas de execução, não no objeto. O único objeto que no final das contas importa é o que está sendo usado para a sincronização.
Espero que a dúvida tenha sido resolvida. Qualquer coisa, é só perguntar. ;)
