Galera, estou com dúvidas em relação ao syncronismo de Threads.
Vou postando alguns códigos para que agente possa discutir sobre estes exemplos, segue este 1º código.
01 public class Exerc64 extends Thread {
02
03 public void restart() {
04 startMe();
05 }
06 public static void startMe() {
07 synchronized (Exerc64.class) {
08 Exerc64.class.notifyAll();
09 System.out.println("Trying to Notify");
10 }
11 }
12 public void run() {
13 try {
14 synchronized (this) {
15 wait();
16 System.out.println("Notified");
17 }
18 } catch (InterruptedException e) { }
19 }
20 public static void main(String[] args) {
21 Exerc64 t1 = new Exerc64();
22 t1.start();
23 t1.restart();
24 }
25 }
Não consegui entender como funciona o syncronismos desta questão.
Oque foi syncronzado na linha 07 ?
Oque foi syncronzado na linha 14? O this representa a thread principal?
Qual thread foi notificada na linha 08? :?: :?: :?: :?: :?:
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?
[quote=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?[/quote]
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…
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.
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.
