Dúvida em Threads

Programação Java
#1

Pessoal tenho o seguinte código:

[code]
…
public static void main(String[] args) throws InterruptedException {

	Thread t = new Thread();

	t.start();

	System.out.println("X");

	synchronized (t) {

		t.wait(5000);

		System.out.println("Y");
	}
}

[/code] No código acima a resposta dessa execução é a exibição de X e Y com uma pausa de 5 segundos entre eles.
O que não estou conseguindo entender é:
Ao comentar a linha 8 ( System.out.println(“X”); ) o programa exibe Y IMEDIATAMENTE sem a espera dos 5 segundos. Por que isso aconteceu ?

[]'s

#2

Esta discussão foi bem esclarecida anteriormente: http://www.guj.com.br/java/74098-thread---wait--notify

#3

Tenho a mesma duvida do colega, e o link postado não achei onde explica o porque dos 5 segundos serem pulados.

#4

Então, já vi algumas pessoas criticando o wait porque confundem com o sleep, não digo que foi o caso de vocês, mas causa confusão mesmo este lance todo.

O único comando em Thread que permite esperar exatamente o tempo (em milissegundos) determinado é o sleep.

O wait ele é utilizado com o notify ou notifyAll para utilizar em caso de necessidade de alternar o trabalho entre threads porque é preciso esperar que a tarefa de um sujeito termine para o outro sujeito seguir. Se a colaboração não for confiável, você ainda tem a opção de utilizar um wait passando como parâmetro um timeout em milissegundos para não ficar dormindo no ponto.

Se você chamar o wait() de uma thread, esperará pela execução dela, mas está exposto a algumas situações ditas espontâneas:

1o) a thread “A” para qual a espera foi conferida poderá ocorrer rapidamente e logo a thread “Main” segue a vida;
2o) se for disparada uma thread “B” em paralelo e a JVM der prioridade para “B”, então “A” poderá ficar adormecida e acordar espontaneamente (*);
3o) se na colaboração entre as threads não houver um acordo para alternarem a vez de cada uma, então o negócio fica mais espontâneo ainda.

(*) O gerenciamento computacional para compartilhamento de tempo quando sofre uma intervenção do programador, ele espera que a intervenção seja coerente, mas também sabe que entre códigos nativos (seus códigos mesmo) misturados com códigos fechados (do Java Standard Edition, JEE ou terceiros) pode haver uma colaboração incoerente que acarrete ônus para uma ou mais thread que deixa de receber prioridade, por isso, o gerente de compatilhamento de tempo de processamento, busca executar algumas revisões em momentos que eu não sei dizer exatamente a regra, isso deve variar conforme o sistema operacional ou até mesmo versão do mesmo.

Acredito que o exemplo do CristianoGDT ilustra o caso 2o e 3o, pois ao entrar:

Uma atividade de I/O e uma thread indiretamente foram abertas e deixou “t” em execução no momento da chamada de wait, então ficou por conta do timeout de 5 segundos terminar a espera quando “t” é somente uma thread neutra e não notifica quando termina. Se não fosse o System.out.println(“X”), “t” já teria acabado e wait simplismente saberia disso e não esperaria até o timeout.

Tente verificar isso pelo estado de “t” (t.getState()), embora seja uma intevenção que modifica o tempo de processamento, por isso é difícil de provar, mas é possível perceber sim.

Para quem estiver interessado em iniciar em threads, leia meu artigo http://www.oracle2java.blogspot.com.br/2012/05/java-threads.html sobre o assunto.

wiliamps

#5