TechCodeview

Multithreading e sincronização são considerados capítulos típicos da programação java. Em empresas de desenvolvimento de jogos, as perguntas da entrevista relacionadas ao multithreading são feitas principalmente. Uma lista de perguntas frequentes da entrevista sobre multithreading e simultaneidade em java é fornecida abaixo.

Perguntas da entrevista multithreading

1) O que é multithreading?

Multithreading é um processo de execução de vários threads simultaneamente. Multithreading é usado para obter multitarefa. Ele consome menos memória e oferece desempenho rápido e eficiente. Suas principais vantagens são:

• Threads compartilham o mesmo espaço de endereço.
• O fio é leve.
• O custo de comunicação entre os processos é baixo.

2) Qual é o fio?

Um thread é um subprocesso leve. É um caminho de execução separado porque cada thread é executado em um stack frame diferente. Um processo pode conter vários threads. Threads compartilham os recursos do processo, mas ainda assim são executados de forma independente.

3) Diferenciar entre processo e thread?

Existem as seguintes diferenças entre o processo e o thread.

• Um programa em execução é chamado de processo, enquanto; Um thread é um subconjunto do processo
• Os processos são independentes, enquanto os threads são o subconjunto do processo.
• Os processos possuem espaços de endereçamento diferentes na memória, enquanto os threads contêm um espaço de endereçamento compartilhado.
• A troca de contexto é mais rápida entre os threads em comparação com os processos.
• A comunicação entre processos é mais lenta e cara do que a comunicação entre threads.
• Qualquer alteração no processo pai não afeta o processo filho, enquanto as alterações no thread pai podem afetar o thread filho.

4) O que você entende por comunicação entre threads?

• O processo de comunicação entre threads sincronizados é denominado comunicação entre threads.
• A comunicação entre threads é usada para evitar a pesquisa de threads em Java.
• A thread é pausada em sua seção crítica e outra thread pode entrar (ou bloquear) na mesma seção crítica para ser executada.
• Ele pode ser obtido pelos métodos wait(), notify() e notifyAll().

5) Qual é o propósito do método wait() em Java?

O método wait() é fornecido pela classe Object em Java. Este método é usado para comunicação entre threads em Java. O java.lang.Object.wait() é usado para pausar o thread atual e esperar até que outro thread não chame o método notify() ou notifyAll(). Sua sintaxe é fornecida abaixo.

espera pública final nula ()

6) Por que o método wait() deve ser chamado a partir do bloco sincronizado?

Devemos chamar o método wait, caso contrário ele irá lançar java.lang.IllegalMonitorStateException exceção. Além disso, precisamos do método wait() para comunicação entre threads com notify() e notifyAll(). Portanto deve estar presente no bloco sincronizado para a comunicação adequada e correta.

7) Quais são as vantagens do multithreading?

A programação multithreading tem as seguintes vantagens:

• Multithreading permite que um aplicativo/programa seja sempre reativo à entrada, mesmo já em execução com algumas tarefas em segundo plano
• O multithreading permite a execução mais rápida de tarefas, pois os threads são executados de forma independente.
• O multithreading fornece melhor utilização da memória cache, pois os threads compartilham os recursos de memória comuns.
• O multithreading reduz o número do servidor necessário, pois um servidor pode executar vários threads ao mesmo tempo.

8) Quais são os estados do ciclo de vida de um Thread?

Um thread pode ter um dos seguintes estados durante seu tempo de vida:

Novo:Nesse estado, um objeto da classe Thread é criado usando um operador new, mas o thread não está ativo. O thread não inicia até chamarmos o método start().Executável:Neste estado, o thread está pronto para ser executado após chamar o método start(). No entanto, o thread ainda não foi selecionado pelo agendador de threads.Correndo:Nesse estado, o agendador de threads seleciona o thread do estado pronto e o thread está em execução.Aguardando/Bloqueado:Nesse estado, um thread não está em execução, mas ainda ativo, ou está aguardando a conclusão do outro thread.Morto/Terminado:Um thread está em estado finalizado ou morto quando o método run() é encerrado.

9) Qual é a diferença entre agendamento preemptivo e divisão de tempo?

No agendamento preemptivo, a tarefa de prioridade mais alta é executada até entrar nos estados de espera ou inativo ou até que uma tarefa de prioridade mais alta passe a existir. Na divisão de tempo, uma tarefa é executada por um intervalo de tempo predefinido e, em seguida, entra novamente no conjunto de tarefas prontas. O agendador então determina qual tarefa deve ser executada em seguida, com base na prioridade e em outros fatores.

10) O que é mudança de contexto?

Na troca de contexto, o estado do processo (ou thread) é armazenado para que possa ser restaurado e a execução possa ser retomada do mesmo ponto posteriormente. A troca de contexto permite que vários processos compartilhem a mesma CPU.

11) Diferenciar entre a classe Thread e a interface Runnable para criar um Thread?

O Thread pode ser criado de duas maneiras.

• Estendendo a classe Thread
• Implementando a interface Runnable

No entanto, as principais diferenças entre as duas formas são fornecidas abaixo:

• Ao estender a classe Thread, não podemos estender nenhuma outra classe, pois Java não permite heranças múltiplas durante a implementação da interface Runnable; também podemos estender outra classe base (se necessário).
• Ao estender a classe Thread, cada thread cria o objeto exclusivo e se associa a ele enquanto implementa a interface Runnable; vários threads compartilham o mesmo objeto
• A classe Thread fornece vários métodos integrados, como getPriority(), isAlive e muitos mais, enquanto a interface Runnable fornece um único método, ou seja, run().

12) O que é o método join()?

O método join() espera que um thread morra. Em outras palavras, faz com que os threads em execução no momento parem de executar até que o thread ao qual ele se junta conclua sua tarefa. O método Join está sobrecarregado na classe Thread das seguintes maneiras.

• public void join() lança InterruptedException
• public void join (longos milissegundos) lança InterruptedException

13) Descreva o propósito e o funcionamento do método sleep().

O método sleep() em java é usado para bloquear um thread por um horário específico, o que significa pausar a execução de um thread por um horário específico. Existem dois métodos para fazer isso.

Sintaxe:

tutorial javafx

• public static void sleep (longos milissegundos) lança InterruptedException
• public static void sleep (longos milissegundos, int nanos) lança InterruptedException

Funcionamento do método sleep()

Quando chamamos o método sleep(), ele pausa a execução do thread atual por um determinado tempo e dá prioridade a outro thread (se disponível). Além disso, quando o tempo de espera é concluído, o thread anterior novamente muda seu estado de espera para executável e entra no estado de execução, e todo o processo funciona assim até que a execução não seja concluída.

14) Qual é a diferença entre os métodos wait() e sleep()?

15) É possível iniciar um tópico duas vezes?

Não, não podemos reiniciar o thread, pois uma vez iniciado e executado, ele vai para o estado Dead. Portanto, se tentarmos iniciar um thread duas vezes, ocorrerá uma runtimeException 'java.lang.IllegalThreadStateException'. Considere o seguinte exemplo.

 public class Multithread1 extends Thread { public void run() { try { System.out.println('thread is executing now........'); } catch(Exception e) { } } public static void main (String[] args) { Multithread1 m1= new Multithread1(); m1.start(); m1.start(); } } 

Saída

 thread is executing now........ Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:708) at Multithread1.main(Multithread1.java:13) 

16) Podemos chamar o método run() em vez de start()?

Sim, chamar o método run() diretamente é válido, mas não funcionará como um thread, mas como um objeto normal. Não haverá troca de contexto entre os threads. Quando chamamos o método start(), ele chama internamente o método run(), que cria uma nova pilha para um thread, enquanto chamar diretamente run() não criará uma nova pilha.

17) E os threads daemon?

Os threads daemon são os threads de baixa prioridade que fornecem suporte e serviços em segundo plano aos threads do usuário. O encadeamento daemon é encerrado automaticamente pela JVM se o programa permanecer apenas com o encadeamento daemon e todos os outros encadeamentos do usuário forem encerrados/morridos. Existem dois métodos para thread daemon disponíveis na classe Thread:

public void setDaemon (status booleano):É usado para marcar o thread daemon do thread ou um thread do usuário.público booleano isDaemon():Ele verifica se o thread é daemon ou não.

18) Podemos tornar o thread do usuário um thread daemon se o thread for iniciado?

Não, se você fizer isso, será lançada IllegalThreadStateException. Portanto, só podemos criar um thread daemon antes de iniciar o thread.

 class Testdaemon1 extends Thread{ public void run(){ System.out.println('Running thread is daemon...'); } public static void main (String[] args) { Testdaemon1 td= new Testdaemon1(); td.start(); setDaemon(true);// It will throw the exception: td. } } 

Saída

 Running thread is daemon... Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1359) at Testdaemon1.main(Testdaemon1.java:8) 

19)O que é gancho de desligamento?

O gancho de desligamento é um encadeamento invocado implicitamente antes do encerramento da JVM. Portanto, podemos usá-lo para limpar o recurso ou salvar o estado quando a JVM for desligada normalmente ou abruptamente. Podemos adicionar um gancho de desligamento usando o seguinte método:

 public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 

Alguns pontos importantes sobre ganchos de desligamento são:

• Os ganchos de desligamento foram inicializados, mas só podem ser iniciados quando ocorreu o encerramento da JVM.
• Os ganchos de desligamento são mais confiáveis ​​que o finalizer() porque há muito menos chances de os ganchos de desligamento não serem executados.
• O gancho de desligamento pode ser interrompido chamando o método halt(int) da classe Runtime.

20)Quando devemos interromper um thread?

Devemos interromper um thread quando quisermos interromper o estado de suspensão ou espera de um thread. Podemos interromper um thread chamando a interrupção() lançando a InterruptedException.

interface comparável java

21) Qual é a sincronização?

A sincronização é a capacidade de controlar o acesso de vários threads a qualquer recurso compartilhado. É usado:

1. Para evitar interferência na linha.
2. Para evitar problemas de consistência.

Quando vários threads tentam realizar a mesma tarefa, existe a possibilidade de um resultado errôneo, portanto, para eliminar esse problema, Java utiliza o processo de sincronização que permite que apenas um thread seja executado por vez. A sincronização pode ser alcançada de três maneiras:

• pelo método sincronizado
• por bloco sincronizado
• por sincronização estática

Sintaxe para bloco sincronizado

 synchronized(object reference expression) { //code block } 

22) Qual a finalidade do bloco Sincronizado?

O bloco Synchronized pode ser utilizado para realizar a sincronização em qualquer recurso específico do método. Apenas um thread por vez pode ser executado em um recurso específico, e todos os outros threads que tentarem entrar no bloco sincronizado serão bloqueados.

• O bloco sincronizado é usado para bloquear um objeto para qualquer recurso compartilhado.
• O escopo do bloco sincronizado é limitado ao bloco ao qual ele é aplicado. Seu escopo é menor que um método.

23) O objeto Java pode ser bloqueado para uso exclusivo por um determinado thread?

Sim. Você pode bloquear um objeto colocando-o em um bloco 'sincronizado'. O objeto bloqueado é inacessível a qualquer thread que não seja aquele que o reivindicou explicitamente.

24) O que é sincronização estática?

Se você tornar qualquer método estático sincronizado, o bloqueio estará na classe e não no objeto. Se usarmos a palavra-chave sincronizada antes de um método, ela bloqueará o objeto (um thread pode acessar um objeto por vez), mas se usarmos staticsynchronous, ela bloqueará uma classe (uma thread pode acessar uma classe por vez). Mais detalhes.

25)Qual é a diferença entre notificar() e notificarAll()?

O notify() é usado para desbloquear um thread em espera, enquanto o método notifyAll() é usado para desbloquear todos os threads em estado de espera.

26) Qual é o impasse?

Deadlock é uma situação em que cada thread está aguardando um recurso que está retido por algum outro thread em espera. Nessa situação, nenhum thread é executado nem tem chance de ser executado. Em vez disso, existe um estado de espera universal entre todos os threads. Deadlock é uma situação muito complicada que pode quebrar nosso código em tempo de execução.

27) Como detectar uma condição de deadlock? Como isso pode ser evitado?

Podemos detectar a condição de deadlock executando o código no cmd e coletando o Thread Dump, e se algum deadlock estiver presente no código, uma mensagem aparecerá no cmd.

Maneiras de evitar a condição de impasse em Java:

Evite bloqueio aninhado:O bloqueio aninhado é o motivo comum para o conflito, pois o conflito ocorre quando fornecemos bloqueios para vários threads, portanto, devemos fornecer um bloqueio para apenas um thread em algum momento específico.Evite bloqueios desnecessários:devemos evitar os bloqueios que não são necessários.Usando junção de thread:A junção de thread ajuda a esperar por um thread até que outro thread não termine sua execução, para que possamos evitar deadlocks usando ao máximo o método join.

28) O que é Thread Scheduler em java?

Em Java, quando criamos os threads, eles são supervisionados com a ajuda de um Thread Scheduler, que faz parte da JVM. O agendador de threads é responsável apenas por decidir qual thread deve ser executado. O agendador de threads usa dois mecanismos para agendar os threads: Preemptivo e Time Slicing.

• Ele seleciona a prioridade do thread.
• Determina o tempo de espera de um thread
• Ele verifica a natureza do thread

29) Cada thread tem sua pilha na programação multithread?

Sim, na programação multithread, cada thread mantém sua própria área de pilha ou área de pilha separada na memória, devido à qual cada thread é independente um do outro.

declaração java

30) Como é alcançada a segurança de um fio?

Se um método ou objeto de classe puder ser usado por vários threads ao mesmo tempo sem qualquer condição de corrida, a classe será thread-safe. A segurança de thread é usada para tornar um programa seguro para uso em programação multithread. Isso pode ser alcançado das seguintes maneiras:

• Sincronização
• Usando palavra-chave volátil
• Usando um mecanismo baseado em bloqueio
• Uso de classes wrapper atômicas

31) O que é condição de corrida?

Uma condição Race é um problema que ocorre na programação multithread quando vários threads são executados simultaneamente, acessando um recurso compartilhado ao mesmo tempo. O uso adequado da sincronização pode evitar a condição Race.

32) Qual é a palavra-chave volátil em java?

A palavra-chave volátil é usada na programação multithread para alcançar a segurança do thread, já que uma alteração em uma variável volátil é visível para todos os outros threads, portanto, uma variável pode ser usada por um thread por vez.

33) O que você entende por pool de threads?

• O pool de threads Java representa um grupo de threads de trabalho, que estão aguardando a alocação da tarefa.
• Threads no pool de threads são supervisionados pelo provedor de serviços que extrai um thread do pool e atribui um trabalho a ele.
• Após a conclusão da tarefa determinada, o thread voltou ao pool de threads.
• O tamanho do pool de threads depende do número total de threads mantidos em reserva para execução.

As vantagens do pool de threads são:

• Usando um pool de threads, o desempenho pode ser aprimorado.
• Usando um pool de threads, pode ocorrer melhor estabilidade do sistema.

Perguntas da entrevista simultânea

34) Quais são os principais componentes da API de simultaneidade?

A API de simultaneidade pode ser desenvolvida usando a classe e as interfaces do pacote java.util.Concurrent. Existem as seguintes classes e interfaces no pacote java.util.Concurrent.

• Executor
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Futuro
• Unidade de tempo (Enum)
• Trava de contagem regressiva
• Barreira Cíclica
• Semáforo
• ThreadFactory
• Queue de bloqueio
• DelayQueue
• Fechaduras
• Phaser

35) Qual é a interface do Executor na API de simultaneidade em Java?

A Interface do Executor fornecida pelo pacote java.util.concurrent é a interface simples usada para executar a nova tarefa. O método execute() da interface Executor é usado para executar algum comando. A sintaxe do método execute() é fornecida abaixo.

void execute (comando executável)

Considere o seguinte exemplo:

 import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { Executor e = Executors.newCachedThreadPool(); e.execute(new Thread()); ThreadPoolExecutor pool = (ThreadPoolExecutor)e; pool.shutdown(); } static class Thread implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 5); System.out.println('Running Thread!'); TimeUnit.SECONDS.sleep(duration); System.out.println('Thread Completed'); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Saída

 Running Thread! Thread Completed 

36) O que é BlockingQueue?

O java.util.concurrent.BlockingQueue é a subinterface de Queue que suporta operações como aguardar a disponibilidade de espaço antes de inserir um novo valor ou aguardar que a fila não fique vazia antes de recuperar um elemento dela. Considere o seguinte exemplo.

 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { BlockingQueue queue = new ArrayBlockingQueue(10); Insert i = new Insert(queue); Retrieve r = new Retrieve(queue); new Thread(i).start(); new Thread(r).start(); Thread.sleep(2000); } static class Insert implements Runnable { private BlockingQueue queue; public Insert(BlockingQueue queue) { this.queue = queue; } @Override public void run() { Random random = new Random(); try { int result = random.nextInt(200); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(10); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(50); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); } catch (InterruptedException e) { e.printStackTrace(); } } } static class Retrieve implements Runnable { private BlockingQueue queue; public Retrieve(BlockingQueue queue) { this.queue = queue; } @Override public void run() { try { System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } } } } 

Saída

 Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5 

37) Como implementar o problema produtor-consumidor usando BlockingQueue?

O problema produtor-consumidor pode ser resolvido usando BlockingQueue da seguinte maneira.

travessia inorder da árvore binária

 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { public static void main(String args[]){ //Creating shared object BlockingQueue sharedQueue = new LinkedBlockingQueue(); //Creating Producer and Consumer Thread Thread prod = new Thread(new Producer(sharedQueue)); Thread cons = new Thread(new Consumer(sharedQueue)); //Starting producer and Consumer thread prod.start(); cons.start(); } } //Producer Class in java class Producer implements Runnable { private final BlockingQueue sharedQueue; public Producer(BlockingQueue sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { for(int i=0; i<10; i++){ try { system.out.println('produced: ' + i); sharedqueue.put(i); } catch (interruptedexception ex) logger.getlogger(producer.class.getname()).log(level.severe, null, ex); consumer class in java implements runnable{ private final blockingqueue sharedqueue; public (blockingqueue sharedqueue) this.sharedqueue="sharedQueue;" @override void run() while(true){ system.out.println('consumed: '+ sharedqueue.take()); logger.getlogger(consumer.class.getname()).log(level.severe, < pre> <p> <strong>Output</strong> </p> <pre> Produced: 0 Produced: 1 Produced: 2 Produced: 3 Produced: 4 Produced: 5 Produced: 6 Produced: 7 Produced: 8 Produced: 9 Consumed: 0 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Consumed: 5 Consumed: 6 Consumed: 7 Consumed: 8 Consumed: 9 </pre> <hr> <h3>38) What is the difference between Java Callable interface and Runnable interface?</h3> <p>The Callable interface and Runnable interface both are used by the classes which wanted to execute with multiple threads. However, there are two main differences between the both : </p> <ul> <li>A Callable interface can return a result, whereas the Runnable interface cannot return any result.</li> <li>A Callable interface can throw a checked exception, whereas the Runnable interface cannot throw checked exception. </li> <li>A Callable interface cannot be used before the Java 5 whereas the Runnable interface can be used.</li> </ul> <hr> <h3>39) What is the Atomic action in Concurrency in Java?</h3> <ul> <li>The Atomic action is the operation which can be performed in a single unit of a task without any interference of the other operations.</li> <li>The Atomic action cannot be stopped in between the task. Once started it fill stop after the completion of the task only. </li> <li>An increment operation such as a++ does not allow an atomic action.</li> <li>All reads and writes operation for the primitive variable (except long and double) are the atomic operation.</li> <li>All reads and writes operation for the volatile variable (including long and double) are the atomic operation.</li> <li>The Atomic methods are available in java.util.Concurrent package. </li> </ul> <hr> <h3>40) What is lock interface in Concurrency API in Java?</h3> <p>The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar to the synchronized block. There are a few differences between the lock and synchronized block that are given below.</p> <ul> <li>Lock interface provides the guarantee of sequence in which the waiting thread will be given the access, whereas the synchronized block doesn&apos;t guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn&apos;t provide that.</li> <li>The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods whereas single synchronized block must be fully contained in a single method.</li> </ul> <hr> <h3>41) Explain the ExecutorService Interface.</h3> <p>The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage the lifecycle. Consider the following example.</p> <pre> import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println(&apos;Shutdown executor&apos;); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println(&apos;tasks interrupted&apos;); } finally { if (!e.isTerminated()) { System.err.println(&apos;cancel non-finished tasks&apos;); } e.shutdownNow(); System.out.println(&apos;shutdown finished&apos;); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println(&apos;Running Task!&apos;); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } </pre> <p> <strong>Output</strong> </p> <pre> Shutdown executor shutdown finished </pre> <hr> <h3>42) What is the difference between Synchronous programming and Asynchronous programming regarding a thread?</h3> <p> <strong>Synchronous programming: </strong> In Synchronous programming model, a thread is assigned to complete a task and hence thread started working on it, and it is only available for other tasks once it will end the assigned task.</p> <p> <strong>Asynchronous Programming: </strong> In Asynchronous programming, one job can be completed by multiple threads and hence it provides maximum usability of the various threads.</p> <hr> <h3>43) What do you understand by Callable and Future in Java?</h3> <p> <strong>Java Callable interface: </strong> In Java5 callable interface was provided by the package java.util.concurrent. It is similar to the Runnable interface but it can return a result, and it can throw an Exception. It also provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.</p> <p> <strong>Syntax:</strong> </p> <p>public interface Callable</p> <p> <strong>Java Future interface:</strong> Java Future interface gives the result of a concurrent process. The Callable interface returns the object of java.util.concurrent.Future.</p> <p>Java Future provides following methods for implementation.</p> <ul> <tr><td>cancel(boolean&#xFFFD;mayInterruptIfRunning):</td> It is used to cancel the execution of the assigned task. </tr><tr><td>get():</td> It waits for the time if execution not completed and then retrieved the result. </tr><tr><td>isCancelled():</td> It returns the Boolean value as it returns true if the task was canceled before the completion. </tr><tr><td>isDone():</td> It returns true if the job is completed successfully else returns false. </tr></ul> <hr> <h3>44. What is the difference between ScheduledExecutorService and ExecutorService interface?</h3> <p>ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package but scheduledExecutorService provides some additional methods to execute the Runnable and Callable tasks with the delay or every fixed time period.</p> <h3>45) Define FutureTask class in Java? </h3> <p>Java FutureTask class provides a base implementation of the Future interface. The result can only be obtained if the execution of one task is completed, and if the computation is not achieved then get method will be blocked. If the execution is completed, then it cannot be re-started and can&apos;t be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;>

38) Qual é a diferença entre a interface Java Callable e a interface Runnable?

A interface Callable e a interface Runnable são usadas pelas classes que desejam executar com vários threads. No entanto, existem duas diferenças principais entre os dois:

• Uma interface Callable pode retornar um resultado, enquanto a interface Runnable não pode retornar nenhum resultado.
• Uma interface Callable pode lançar uma exceção verificada, enquanto a interface Runnable não pode lançar uma exceção verificada.
• Uma interface Callable não pode ser usada antes do Java 5, enquanto a interface Runnable pode ser usada.

39) Qual é a ação atômica em simultaneidade em Java?

• A ação atômica é a operação que pode ser realizada em uma única unidade de uma tarefa sem qualquer interferência das demais operações.
• A ação atômica não pode ser interrompida entre as tarefas. Uma vez iniciado, o preenchimento é interrompido somente após a conclusão da tarefa.
• Uma operação de incremento como a++ não permite uma ação atômica.
• Todas as operações de leitura e gravação para a variável primitiva (exceto long e double) são operações atômicas.
• Todas as operações de leitura e gravação para a variável volátil (incluindo long e double) são operações atômicas.
• Os métodos Atomic estão disponíveis no pacote java.util.Concurrent.

40) O que é interface de bloqueio na API de simultaneidade em Java?

A interface java.util.concurrent.locks.Lock é usada como mecanismo de sincronização. Funciona de forma semelhante ao bloco sincronizado. Existem algumas diferenças entre o bloqueio e o bloco sincronizado fornecidas a seguir.

• A interface Lock fornece a garantia da sequência em que o thread em espera receberá o acesso, enquanto o bloco sincronizado não o garante.
• A interface de bloqueio oferece a opção de tempo limite se o bloqueio não for concedido, enquanto o bloco sincronizado não fornece isso.
• Os métodos da interface Lock, ou seja, Lock() e Unlock() podem ser chamados em métodos diferentes, enquanto um único bloco sincronizado deve estar totalmente contido em um único método.

41) Explique a interface ExecutorService.

A interface ExecutorService é a subinterface da interface Executor e adiciona recursos para gerenciar o ciclo de vida. Considere o seguinte exemplo.

 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println('Shutdown executor'); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println('tasks interrupted'); } finally { if (!e.isTerminated()) { System.err.println('cancel non-finished tasks'); } e.shutdownNow(); System.out.println('shutdown finished'); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println('Running Task!'); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Saída

 Shutdown executor shutdown finished 

42) Qual a diferença entre programação síncrona e programação assíncrona em relação a um thread?

Programação síncrona: No modelo de programação síncrona, um thread é atribuído para concluir uma tarefa e, portanto, o thread começou a trabalhar nele, e só estará disponível para outras tarefas quando terminar a tarefa atribuída.

Programação Assíncrona: Na programação assíncrona, um trabalho pode ser concluído por vários threads e, portanto, fornece usabilidade máxima dos vários threads.

43) O que você entende por Callable e Future em Java?

Interface Java que pode ser chamada: Em Java5, a interface chamável era fornecida pelo pacote java.util.concurrent. É semelhante à interface Runnable, mas pode retornar um resultado e lançar uma exceção. Ele também fornece um método run() para execução de um thread. Java Callable pode retornar qualquer objeto, pois usa Genérico.

Sintaxe:

interface pública chamável

Interface Java Futura: A interface Java Future fornece o resultado de um processo simultâneo. A interface Callable retorna o objeto de java.util.concurrent.Future.

Java Future fornece os seguintes métodos para implementação.

cancelar(booleano�mayInterruptIfRunning):É usado para cancelar a execução da tarefa atribuída.pegar():Ele aguarda o tempo se a execução não for concluída e então recupera o resultado.é cancelado():Ele retorna o valor booleano, pois retorna verdadeiro se a tarefa foi cancelada antes da conclusão.é feito():Ele retorna verdadeiro se o trabalho for concluído com sucesso, caso contrário, retorna falso.

44. Qual é a diferença entre a interface ScheduledExecutorService e ExecutorService?

ExecutorServcie e ScheduledExecutorService são interfaces do pacote java.util.Concurrent, mas ScheduledExecutorService fornece alguns métodos adicionais para executar as tarefas Runnable e Callable com atraso ou a cada período de tempo fixo.

45) Definir a classe FutureTask em Java?

A classe Java FutureTask fornece uma implementação básica da interface Future. O resultado só pode ser obtido se a execução de uma tarefa for concluída, e se o cálculo não for alcançado o método get será bloqueado. Se a execução for concluída, ela não poderá ser reiniciada e não poderá ser cancelada.

Sintaxe

classe pública FutureTask estende Object implementa RunnableFuture