As threads são recursos que permitem que múltiplas execuções...
I. São considerados possíveis estados de uma thread: novo; executável; espera; espera programada; e, concluído. II. Na maioria dos Sistemas Operacionais, cada thread recebe uma pequena quantidade de tempo do processador denominada quantum. III. Implementar a interface Runnable do pacote Java.lang é uma forma de criar um aplicativo de múltiplas threads, utilizando classes e métodos predefinidos para criar threads que executem objetos Runnables.
Está correto o que se afirma em
A execução de uma thread pode passar por 4 estados:
1 - Novo;
2 - Executável;
3 - Bloqueado e;
4 - Encerrado.
Complementando o comentário do colega Tiago, segundo DEITEL (JAVA, Como programar, 8ª ed., capítulo 26, página 805) as threads podem assumir os seguintes estados:
- Novo
- Executável
- Espera
- Espera Cronometrada
- Terminado
- Bloqueado
GAB: D
Em java:
Tipo de constante: Novo
Descrição: estado do thread para um thread que ainda não foi iniciado.
Declaração: Thread public static final.State NEW
Tipo de constante: Executável
Descrição: estado do thread para um thread executável. Um encadeamento no estado executável está sendo executado na máquina virtual Java, mas pode estar aguardando outros recursos do sistema operacional, como processador.
Declaração: public static final Thread.State RUNNABLE
Tipo de constante: Bloqueado
Descrição: estado de thread para um thread bloqueado esperando por um bloqueio de monitor. Um thread no estado bloqueado está aguardando que um bloqueio de monitor entre em um bloco / método sincronizado ou reinsira um bloco / método sincronizado após chamar Object.wait().
Declaração: público static final Thread.State BLOCKED
Tipo constante: Esperando
Descrição: estado do thread para um thread em espera. Estado do thread para um thread em espera. Um thread está em estado de espera devido à chamada de um dos seguintes métodos:
- Object.wait sem tempo limite
- sem tempo limite
- LockSupport.park
Um encadeamento no estado de espera está aguardando que outro encadeamento execute uma ação específica.
Declaração: público static final Thread.State WAITING
Tipo de constante: espera cronometrada
Descrição: estado do thread para um thread em espera com um tempo de espera especificado. Um encadeamento está no estado de espera cronometrado devido à chamada de um dos seguintes métodos com um tempo de espera positivo especificado:
- Thread.sleep
- Object.wait com tempo limite
- Thread.join com tempo limite
- LockSupport.parkNanos
- LockSupport.parkUntil
Declaração: thread public static final.State TIMED_WAITING
Tipo de constante: Terminado
Descrição: estado do thread para um thread encerrado. O thread concluiu a execução
Declaração: thread public static final.State TERMINATED
Fonte:https://acervolima.com/ciclo-de-vida-e-estados-de-um-thread-em-java/
d-
A thread state. A thread can be in one of the following states:
NEW
A thread that has not yet started is in this state.
RUNNABLE
A thread executing in the Java virtual machine is in this state.
BLOCKED
A thread that is blocked waiting for a monitor lock is in this state.
WAITING
A thread that is waiting indefinitely for another thread to perform a particular action is in this state.
TIMED_WAITING
A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.
TERMINATED
A thread that has exited is in this state.
https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.State.html
ex.: de uso de threads em java:
public class Runnableee {
public static void main(String[] args) {
// criar (new Thread) e iniciar thread (new Runnable)
Thread thread1 = new Thread(new MyRunnable("Thread 1"));
thread1.start();
// outra thread
Thread thread2 = new Thread(new MyRunnable("Thread 2"));
thread2.start();
}
// class para Runnable interface
static class MyRunnable implements Runnable {
private String threadName;
public MyRunnable(String threadName) {
this.threadName = threadName;
}
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println(threadName + ": Count " + i);
try {
Thread.sleep(1000); // Pausa 1 s
} catch (InterruptedException e) {
System.out.println(threadName + " interrupted.");
}
}
System.out.println(threadName + " finished.");
}
}
}
A alternativa correta é a D - II e III, apenas.
Vamos entender o porquê analisando cada afirmativa:
II. Essa afirmativa está correta, pois em sistemas operacionais modernos, o escalonamento de threads é geralmente feito através de um mecanismo conhecido como time slicing, onde cada thread recebe uma fração de tempo para executar em um núcleo do processador, conhecida como quantum. Isso permite que várias threads pareçam estar rodando simultaneamente, mesmo em processadores com um único núcleo.
III. Esta afirmativa também está correta. Em Java, uma das maneiras de se criar uma thread é implementando a interface Runnable. Um objeto que implementa esta interface pode ser passado para o construtor de um objeto da classe Thread, que pode ser iniciado com o método start(), executando o código definido no método run() em uma nova thread.
No entanto, a afirmativa I não está completamente correta. Os estados de uma thread em Java são: NEW (nova), RUNNABLE (executável), BLOCKED (bloqueada), WAITING (esperando indefinidamente), TIMED_WAITING (esperando por um tempo programado) e TERMINATED (concluído). O termo "espera programada" poderia ser interpretado como TIMED_WAITING, mas a palavra específica "espera" poderia causar confusão, pois não é um termo utilizado para descrever um estado de thread em Java. A confusão provém do uso do termo "espera" ao invés de "WAITING" ou "TIMED_WAITING", que são os termos corretos para descrever os estados de espera de uma thread em Java.
Com base no exposto acima, podemos concluir que a alternativa correta é realmente a D - II e III, apenas, pois apenas essas duas afirmativas estão corretas e de acordo com os conceitos de programação multithread em Java.