Syncronizando Threads

ate hj tenho confusao com isso!!

o camilolopes vc sabe que esta questão é do simulado do whizlabs, apenas mudei o nome da classe.
Vc já viu ela???
Fica naquele 1º simulado “Diagnostic Exam”… Qual o seu score no neste primeiro simulado?

Confesso que também fiquei confuso.

Primeiro pq os dois métodos adquirem locks em objetos diferentes.

Na linha 7, o lock é adquirido em Exerc64.class e na linha 14, em uma instancia de Exerc64 .

Como entao a linha 08 vai notificar a instância t1, se essa instancia nao estah no pool de waiting de T1, mas no proprio pool de wait?

Alguém aí entende com isso funciona?

Heider Matos:

o camilolopes vc sabe que esta questão é do simulado do whizlabs, apenas mudei o nome da classe.
Vc já viu ela???
Fica naquele 1º simulado “Diagnostic Exam”… Qual o seu score no neste primeiro simulado?

to respondendo de quizz e learning mode a certification mode nao fiz nenhum ainda… mais em quiz to ± e as vezes ate bom… a learning mode qdo chega a partir do cap 7 da kathy ehhe o bixo pega whilabs tem muita questao que vc ver no kathy em diante da kathy o cap 8 e 9 ave maria nem se fala… questao demais… mais nao to indow bem nao… to revisando o livro da kathy mais começei a me senti inseguro apos alguns simulados

Comecei a fazer simulados do whizlabs e não estou indo muito bem, pelo menos nos primeiros que fiz fiquei sempre na média de 50% a 55%.
Meu maior problema esta sendo o ingles, a maioria das questões que erro são interpretativas, pois nem da para copiar as perguntas e respotas para jogar em um tradutor web, para ver se ajuda. hauhauhuhauah… é tudo bloqueado.
Já nos mocks estou tirando na média de 80%, no examulator tirei 87%, quano eu estiver numa média boa no whizlabs, marco minha prova. rsssssssss…

Mudando de assunto, quem vai poder nos ajudar com esta questão…

Esse código não sincroniza!

Primeiro que os locks são diferentes, então o notifyAll não notifica a thread que está em waiting. Segundo que existe boas chances de o método startMe rodar antes do run, o que faz que a notificação seja lançada antes do wait, ou seja, a thread vai entrar em wait e depois disso não rola nenhum notify (se rolar, ainda eh errado)

Seguinte vamos tentar entender corretamente, quando “t1” chama o método start(), esta thread entra em execução, certo… depois dentro do método run() existe um bloco sincronizado que obtém o bloqueio(this), quer dizer que “t1” obeteve o bloqueio, depois chamou o método wait() e entrou para o estado executavel, certo…

Quando “t1” chamou o método start(), a thread “main” continuou a sua execução e chamou o método restart(), onde também existe um bloco sincronizado, que obtem o bloqueio de Exerc67.class(que neste caso seria a thread main), e notificou todas as threads do seu poll de espera, que no caso não tem niguém e depois printa “Trying to Notify”.

Já a thread “t1” continua no estado executável ja que ela não foi notificada.

Isso foi oque eu consegui entender, caso esteja errado favor me corrigirem, pois tentei apenas interpretar esta questão.
Ajudem a gente ai galera.

Cheguei à mesma conclusão e resolvi fazer um teste aqui.

Rodei o código e não tem santo que faça t1 sair do wait… rs

Então minha explicação desta questão esta correta?
Mas tem um porém, eu não consigo entender muito bem, quando se diz que obtem o bloqueio do Objeto, do objeto quer dizer oque ?? de onde??? Da classe ThreadA!!!
Olha esse exemplo:

public class ThreadA {
	public static void main(String[] args) {
		ThreadB b = new ThreadB();
		b.start();
		synchronized (b) {
			try {
				System.out.println("Waiting for b to complete...");
				b.wait();
			}catch (Exception e) { }
			System.out.println("Total is: " + b.total);
		}
	}
}

public class ThreadB extends Thread {
	int total;
	public void run() {
		synchronized (this) {
			for(int i=0; i < 1000; i++) {
				total += i;
				System.out.println(total);
			}
			notify();
		}
	}
}

Foi criado uma instancia de ThreadB chamada “b”, depois foi chamado o método start(), nisso a thread “main” continuo a sua execução e a referência “b” obteve o bloqueio, e chamou o método wait() fazendo com que a thread “main” entre para o extado executavel na lista de espera de “b” e fique aguardando uma notificação de “b”, que esta calculando
um total. Depois que for finalizado o laço de repetição “b” notifica a thread main que esta na sua lista de espera, então a thread main entra no bloco sincronizado da classe ThreadA, printa “Waiting for b to complete…”, deposi printa "Total is: " + b.total.

Seria isso… me confundo na hora da sincronização…
O bloco sincronizado de que classe é executado primeiro???
Por exemplo, ta certo afirmar que b obteve o bloqueio e main entrou na sua lista de espera… Depois quando b notificou, apartir de que lugar a thread main voltou a executar… Do inicio do bloco sincronizado???
Dúvidas, dúvidas e mais dúvidas…

Eu que, na linha 7 ele está synchronizando a classe que é(ou melhor) era uma thread na linha 14 ele synchroniza a thread que tiver sendo executada no momento.