Analise o código Java apresentado a seguir.public class Main...

Alternativa correta: C - A1 B1 A2 B2 B3 A3 B4 A4 B5 A5

Para entender o porquê da alternativa C ser a correta, precisamos analisar como as threads em Java funcionam. Uma thread é uma linha de execução independente dentro de um programa. No código em questão, temos duas threads em execução: a thread principal (main thread), e a thread criada a partir da instância da classe Main, que estende a classe Thread.

A thread principal executa o loop que imprime "A" seguido de um número, com um intervalo de sono de 1100 milissegundos entre as impressões. A outra thread, criada e iniciada com o método start(), executa o método run(), que imprime "B" seguido de um número, com um intervalo de sono de 700 milissegundos.

Devido a esses intervalos de sono serem diferentes (700ms para "B" e 1100ms para "A"), as impressões das letras vão se intercalar. A thread que executa "B" vai imprimir mais rapidamente do que a thread que executa "A".

A primeira impressão será "A1", pois a thread principal é a primeira a executar. Em seguida, antes que a thread principal termine seu sono de 1100ms, a outra thread despertará de seu sono de 700ms e imprimirá "B1". Esse padrão continuará, com "B" sendo impresso antes de "A" após a primeira sequência, devido ao menor tempo de sono de "B".

Por isso, a sequência correta de saída será A1 B1 A2 B2 B3 A3 B4 A4 B5 A5, pois após a primeira impressão, a thread "B" sempre acordará antes da thread "A", exceto após a impressão de "B5", onde não haverá mais impressão de "B" e "A" imprimirá por último.

Essa questão avalia o entendimento de concorrência e como as threads se comportam em relação ao seu tempo de sono (sleep) e execução.

Tempo (ms):  0 700 1400 2100 2800     3500  4200

Tempo (ms):  0       1100                 2200    3300           4400

Main Thread: A1       A2                     A3          A4              A5 

Outra Thread:      B1        B2       B3     B4        B5   

Sequencia: A1 B1 A2 B2 B3 A3 B4 A4 B5 A5

Complicado esses códigos em linha, os candidatos não tem um tempo de paz.

Benedito, é pra treinar pros legados sem formatação que a gente vai ter que pegar kkkkk

O método main cria uma nova instância da classe Main e inicia uma thread através do método start(). Enquanto a nova thread é executada, a thread principal (a que está no método main) continua sua execução. O loop no método main imprime "A" seguido por um número e pausa por 1100 milissegundos entre cada iteração.

A nova thread (que é a que executa o método run) inicia após a chamada do start(). Ela executa um loop similar, mas imprime "B" seguido por um número e pausa por 700 milissegundos entre cada iteração.

Considerando que não há interrupções devido a processos externos e assumindo que a ordem de execução é consistente, a ordem esperada de saída seria:

B1 A1 B2 A2 B3 A3 B4 A4 B5 A5

Portanto, a alternativa correta é a letra D.

Resposta C:

Tempo (ms), Print

0000, A1

0700, B1

1100, A2

1400, B2

2100, B3

2200, A3

2800, B4

3300, A4

3500, B5

4400, A5

Código modificado para facilitar a compreensão (uma pena que a identação não é mantida):

public class Main extends Thread {

private static long start;

public static void main(String[] args) {

start = System.currentTimeMillis();

System.out.println("\n#### Time is ms = " + (System.currentTimeMillis() - start));

System.out.println("in A: main method started");

Main thread = new Main();

System.out.println("in A: before thread.start()");

thread.start();

System.out.println("in A: after thread.start()");

for (int k=1; k<=5; k++) {

if (k != 1) {

System.out.println("\n#### Time is ms = " + (System.currentTimeMillis() - start));

}

System.out.println("in A: start loop k=" + k);

System.out.println("A" + k);

System.out.println("in A: will sleep for 1100...");

try { Thread.sleep(1100); }

catch (InterruptedException ex) {}

}

}

public void run() {

System.out.println("in B: run method started");

for (int k=1; k<=5; k++) {

System.out.println("in B: start loop k=" + k);

try {

System.out.println("in B: will sleep for 700...");

Thread.sleep(700);

}

catch (InterruptedException ex) {}

System.out.println("\n#### Time is ms = " + (System.currentTimeMillis() - start));

System.out.println("B" + k);

}

}

}

Saída:

#### Time is ms = 0

in A: main method started

in A: before thread.start()

in A: after thread.start()

in B: run method started

in B: start loop k=1

in B: will sleep for 700...

in A: start loop k=1

A1

in A: will sleep for 1100...

#### Time is ms = 722

B1

in B: start loop k=2

in B: will sleep for 700...

#### Time is ms = 1123

in A: start loop k=2

A2

in A: will sleep for 1100...

#### Time is ms = 1424

B2

in B: start loop k=3

in B: will sleep for 700...

#### Time is ms = 2125

B3

in B: start loop k=4

in B: will sleep for 700...

#### Time is ms = 2224

in A: start loop k=3

A3

in A: will sleep for 1100...

#### Time is ms = 2826

B4

in B: start loop k=5

in B: will sleep for 700...

#### Time is ms = 3325

in A: start loop k=4

A4

in A: will sleep for 1100...

#### Time is ms = 3526

B5

#### Time is ms = 4425

in A: start loop k=5

A5

in A: will sleep for 1100...