Duvida threads

Respostas corretas D e F:

As duas primeiras saídas in e pre não tem ordem garantida, porque são executas em threads separadas main e t.

A última saída post é sempre a última coisa a acontecer no programa, por causa da chamada t.join() que lança uma exceção.

flw!

agora tem que abstrair, é devaneio puro. nao tem jeito.
imagine que cada linha é um thread em execuçao.
aperta o cinto

é mais ou menos assim: a linha da esquera é o Thread principal (criado pelo método main) o da esquerda vc disparou com .start();

main       |\   t.start();   
            |  \   // vai executar o metodo run, nao se sabe quando, mas vai
            |    \           
            |      \
            |        \
            |          \
            |           /
            |         /     
            |       /        
            |     /     
            |   /
t.join();   | /         // o thread principal vai esperar pela execução do thread que vc estartou (t), 
            |             // e nós sabemos que  "post " so será exibido depois que "in " e "pre " forem executados, 
                          // que pode ser em qualquer ordem 
                          // "in " e "pre " ou "pre " e "in "

espero ter ajudado.

Anderson Gomes.

O Thread.sleep(2000) não garante q pré seja mostrado 1º???

Thread.sleep(2000) faz apenas com que a Thread que esta sendo executada no momento seja parada por 2 segundos, isto porque o parâmetro que o método recebe é em milisegundos.

Abraços, espero ter ajudado!

Thread.sleep(2000) pode mandar “main” parar 2s entao?

numa analise mais simples, basta vc ver que “pre post” tem que sair nesta ordem…

joaosavio, pode sim.

Você pode perceber que este método é estático e tu não faz nenhuma referência a qualquer Thread.

Na verdade eu testando e compilando a resposta certa sempre seria “pre in post”.

class A implements Runnable{ public void run() { try { Thread.sleep(2000); } catch (Exception e) { } System.out.print("in "); // 3 - Então "in" vai esperar 2s, enquanto isso a thread main já chamou o "pre" e logicamente quando terminar aqui vai chamar o "post" } public static void main(String [] args) { Thread t = new Thread(new A()); t.start(); // 1 - start chama o run(), mais run esta dormindo por 2s. System.out.print("pre "); // 2- então a thread main não vai ficar esperando e chama logo o "pre" try { t.join(); } catch (Exception e) { } // 4 - Isso aqui é de lei, vai imprimir por ultimo porq chama a t.join() e esse espera a thread morrer. System.out.print("post "); } }

Favor me corrija se eu tiver falando besteira.

Sabe que olhando novamente eu acho que a resposta é pre in post mesmo…

o in tem que terminar ants do post, ja que é chamado o join().

Pode ser “pre in post” ou “in pre post”.
Na prática, só sairá o “pre in post”.
Em teoria, na meia-noite de uma sexta-feira 13 de lua cheia “in pre post” aparecerá. Não há nada que garante que “pre” venha antes de “in”, então é como se os dois estivessem apostando corrida. O porém é que “in” sai 2 segundos atrasado nesta corrida, e por isso provavelmente perde a corrida. Mas “provavelmente perde” não significa “sempre perde”.

Quanto ao “post”, ele obviamente vem depois do “pre”, pois está depois na mesma Thread. Como o "post"está depois do join, então ele também está depois do “in”.

A thread dando sleep de 2s não garante que a outra será executada?

Não. A thread do “in” vai para o estado blocked, enquanto que a thread principal está no estado runnable. Isso não significa necessariamente que a thread principal irá para o estado running antes que a outra volte a runnable. Em teoria é possível que a thread do “in” vá para blocked, acorde e volte para runnable e vá para running enquanto que a thread principal saia do running para o runnable por algum motivo qualquer (o sistema operacional pode decidir escalonar o processador para outra coisa) e só volte para running depois que a thread do “in” tiver feito o System.out.