TechCodeview

Il multithreading e la sincronizzazione sono considerati il ​​capitolo tipico della programmazione Java. Nelle società di sviluppo di giochi, vengono poste principalmente domande di intervista relative al multithreading. Di seguito è riportato un elenco delle domande più frequenti sul multithreading Java e sui colloqui di concorrenza.

Domande di intervista multithreading

1) Cos'è il multithreading?

Il multithreading è un processo di esecuzione di più thread contemporaneamente. Il multithreading viene utilizzato per ottenere il multitasking. Consuma meno memoria e offre prestazioni veloci ed efficienti. I suoi principali vantaggi sono:

• I thread condividono lo stesso spazio di indirizzi.
• Il filo è leggero.
• Il costo della comunicazione tra i processi è basso.

2) Qual è il filo conduttore?

Un thread è un sottoprocesso leggero. È un percorso di esecuzione separato perché ogni thread viene eseguito in uno stack frame diverso. Un processo può contenere più thread. I thread condividono le risorse del processo, ma vengono comunque eseguiti in modo indipendente.

3) Distinguere tra processo e thread?

Esistono le seguenti differenze tra il processo e il thread.

• Un programma in esecuzione è chiamato processo mentre; Un thread è un sottoinsieme del processo
• I processi sono indipendenti mentre i thread sono il sottoinsieme del processo.
• I processi hanno uno spazio di indirizzi diverso in memoria, mentre i thread contengono uno spazio di indirizzi condiviso.
• Il cambio di contesto è più veloce tra i thread rispetto ai processi.
• La comunicazione tra processi è più lenta e costosa della comunicazione tra thread.
• Qualsiasi modifica nel processo padre non influisce sul processo figlio mentre le modifiche nel thread padre possono influenzare il thread figlio.

4) Cosa intendi per comunicazione inter-thread?

• Il processo di comunicazione tra thread sincronizzati è definito comunicazione inter-thread.
• La comunicazione tra thread viene utilizzata per evitare il polling dei thread in Java.
• L'esecuzione del thread viene sospesa nella sua sezione critica e un altro thread può entrare (o bloccarsi) nella stessa sezione critica per essere eseguito.
• Può essere ottenuto dai metodi wait(), notify() e notifyAll().

5) Qual è lo scopo del metodo wait() in Java?

Il metodo wait() è fornito dalla classe Object in Java. Questo metodo viene utilizzato per la comunicazione tra thread in Java. java.lang.Object.wait() viene utilizzato per mettere in pausa il thread corrente e attendere finché un altro thread non chiama il metodo notify() o notifyAll(). La sua sintassi è riportata di seguito.

attesa vuoto finale pubblico()

6) Perché il metodo wait() deve essere chiamato dal blocco sincronizzato?

Dobbiamo chiamare il metodo wait altrimenti verrà lanciato java.lang.IllegalMonitorStateException eccezione. Inoltre, abbiamo bisogno del metodo wait() per la comunicazione tra thread con notify() e notifyAll(). Pertanto deve essere presente nel blocco sincronizzato per la corretta e corretta comunicazione.

7) Quali sono i vantaggi del multithreading?

La programmazione multithread presenta i seguenti vantaggi:

• Il multithreading consente a un'applicazione/programma di essere sempre reattivo all'input, anche già in esecuzione con alcune attività in background
• Il multithreading consente un'esecuzione più rapida delle attività, poiché i thread vengono eseguiti in modo indipendente.
• Il multithreading fornisce un migliore utilizzo della memoria cache poiché i thread condividono le risorse di memoria comuni.
• Il multithreading riduce il numero di server richiesti poiché un server può eseguire più thread alla volta.

8) Quali sono gli stati nel ciclo di vita di un Thread?

Un thread può avere uno dei seguenti stati durante la sua vita:

Nuovo:In questo stato, viene creato un oggetto della classe Thread utilizzando un nuovo operatore, ma il thread non è attivo. Il thread non si avvia finché non chiamiamo il metodo start().Eseguibile:In questo stato, il thread è pronto per essere eseguito dopo aver chiamato il metodo start(). Tuttavia, il thread non è ancora selezionato dallo scheduler dei thread.Corsa:In questo stato, lo scheduler del thread preleva il thread dallo stato pronto e il thread è in esecuzione.In attesa/Bloccato:In questo stato, un thread non è in esecuzione ma è ancora attivo oppure è in attesa che l'altro thread finisca.Morto/Terminato:Un thread è in stato terminato o inattivo quando il metodo run() termina.

9) Qual è la differenza tra la pianificazione preventiva e il time slicing?

Nella pianificazione preventiva, l'attività con la priorità più alta viene eseguita finché non entra nello stato di attesa o inattivo o finché non viene creata un'attività con priorità più alta. Con il time slicing, un'attività viene eseguita per un intervallo di tempo predefinito e quindi rientra nel pool di attività pronte. Lo scheduler determina quindi quale attività deve essere eseguita successivamente, in base alla priorità e ad altri fattori.

10) Cos'è il cambio di contesto?

Nel cambio di contesto lo stato del processo (o thread) viene memorizzato in modo che possa essere ripristinato e l'esecuzione possa essere ripresa dallo stesso punto in seguito. Il cambio di contesto consente a più processi di condividere la stessa CPU.

11) Distinguere tra la classe Thread e l'interfaccia Runnable per creare un Thread?

Il thread può essere creato utilizzando due modi.

• Estendendo la classe Thread
• Implementando l'interfaccia Runnable

Tuttavia, le differenze principali tra i due metodi sono riportate di seguito:

• Estendendo la classe Thread, non possiamo estendere nessun'altra classe, poiché Java non consente eredità multiple durante l'implementazione dell'interfaccia Runnable; possiamo anche estendere altre classi base (se richiesto).
• Estendendo la classe Thread, ciascun thread crea l'oggetto univoco e si associa ad esso durante l'implementazione dell'interfaccia Runnable; più thread condividono lo stesso oggetto
• La classe Thread fornisce vari metodi integrati come getPriority(), isAlive e molti altri mentre l'interfaccia Runnable fornisce un singolo metodo, ovvero run().

12) Cosa significa il metodo join()?

Il metodo join() attende che un thread muoia. In altre parole, fa sì che i thread attualmente in esecuzione interrompano l'esecuzione finché il thread a cui si unisce non completa la sua attività. Il metodo Join viene sovraccaricato nella classe Thread nei seguenti modi.

• public void join() genera InterruptedException
• public void join (lunghi millisecondi) genera InterruptedException

13) Descrivere lo scopo e il funzionamento del metodo sleep().

Il metodo sleep() in Java viene utilizzato per bloccare un thread per un periodo particolare, il che significa che mette in pausa l'esecuzione di un thread per un tempo specifico. Esistono due metodi per farlo.

Sintassi:

Java casuale matematica casuale

• Il sonno vuoto statico pubblico (lunghi millisecondi) genera InterruptedException
• il sonno vuoto statico pubblico (millisecondi lunghi, int nanos) genera InterruptedException

Funzionamento del metodo sleep()

Quando chiamiamo il metodo sleep(), mette in pausa l'esecuzione del thread corrente per il tempo specificato e dà priorità a un altro thread (se disponibile). Inoltre, una volta completato il tempo di attesa, il thread precedente cambia nuovamente il suo stato da in attesa a eseguibile e entra nello stato di esecuzione, e l'intero processo funziona così finché l'esecuzione non viene completata.

14) Qual è la differenza tra il metodo wait() e il metodo sleep()?

15) È possibile iniziare una discussione due volte?

No, non possiamo riavviare il thread, poiché una volta avviato ed eseguito, passa allo stato Dead. Pertanto, se proviamo ad avviare un thread due volte, verrà restituita una runtimeException 'java.lang.IllegalThreadStateException'. Considera il seguente esempio.

 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(); } } 

Produzione

 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) Possiamo chiamare il metodo run() invece di start()?

Sì, chiamare direttamente il metodo run() è valido, ma non funzionerà come thread, ma funzionerà come un oggetto normale. Non ci sarà cambio di contesto tra i thread. Quando chiamiamo il metodo start(), chiama internamente il metodo run(), che crea un nuovo stack per un thread mentre la chiamata diretta a run() non creerà un nuovo stack.

17) E i thread del demone?

I thread daemon sono thread a bassa priorità che forniscono il supporto e i servizi in background ai thread dell'utente. Il thread daemon viene terminato automaticamente dalla JVM se il programma rimane solo con il thread daemon e tutti gli altri thread utente vengono terminati/morti. Sono disponibili due metodi per il thread demone nella classe Thread:

public void setDaemon(stato booleano):Utilizzato per contrassegnare il thread del demone del thread o un thread dell'utente.booleano pubblico isDaemon():Controlla che il thread sia demone o meno.

18)Possiamo rendere il thread utente come thread demone se il thread è avviato?

No, se lo fai, verrà lanciata IllegalThreadStateException. Pertanto, possiamo solo creare un thread demone prima di avviare il 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. } } 

Produzione

 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) Cos'è il gancio di spegnimento?

L'hook di spegnimento è un thread che viene richiamato implicitamente prima che JVM si spenga. Quindi possiamo usarlo per eseguire la pulizia della risorsa o salvare lo stato quando JVM si spegne normalmente o all'improvviso. Possiamo aggiungere il hook di spegnimento utilizzando il seguente metodo:

gestore attività per linux

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

Alcuni punti importanti sugli hook di arresto sono:

• Gli hook di arresto sono inizializzati ma possono essere avviati solo quando si è verificato l'arresto della JVM.
• Gli hook di spegnimento sono più affidabili di finalizer() perché ci sono molte meno possibilità che gli hook di spegnimento non vengano eseguiti.
• L'hook di shutdown può essere interrotto chiamando il metodo halt(int) della classe Runtime.

20)Quando dobbiamo interrompere un thread?

Dovremmo interrompere un thread quando vogliamo interrompere lo stato di sonno o di attesa di un thread. Possiamo interrompere un thread chiamando l'interruzione() lanciando l'InterruptedException.

21) Cos'è la sincronizzazione?

La sincronizzazione è la capacità di controllare l'accesso di più thread a qualsiasi risorsa condivisa. È solito:

1. Per evitare interferenze con il filo.
2. Per evitare problemi di coerenza.

Quando più thread tentano di eseguire la stessa attività, esiste la possibilità di un risultato errato, quindi per rimuovere questo problema, Java utilizza il processo di sincronizzazione che consente l'esecuzione di un solo thread alla volta. La sincronizzazione può essere ottenuta in tre modi:

• con il metodo sincronizzato
• tramite blocco sincronizzato
• mediante sincronizzazione statica

Sintassi per blocco sincronizzato

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

22) Qual è lo scopo del blocco Sincronizzato?

Il blocco Synchronized può essere utilizzato per eseguire la sincronizzazione su qualsiasi risorsa specifica del metodo. Solo un thread alla volta può essere eseguito su una particolare risorsa e tutti gli altri thread che tentano di accedere al blocco sincronizzato vengono bloccati.

• Il blocco sincronizzato viene utilizzato per bloccare un oggetto per qualsiasi risorsa condivisa.
• L'ambito del blocco sincronizzato è limitato al blocco a cui viene applicato. Il suo ambito è inferiore a quello di un metodo.

23) È possibile bloccare un oggetto Java per l'uso esclusivo da parte di un determinato thread?

SÌ. Puoi bloccare un oggetto inserendolo in un blocco 'sincronizzato'. L'oggetto bloccato è inaccessibile a qualsiasi thread diverso da quello che lo ha rivendicato esplicitamente.

24) Cos'è la sincronizzazione statica?

Se rendi sincronizzato un metodo statico, il blocco sarà sulla classe e non sull'oggetto. Se utilizziamo la parola chiave sincronizzata prima di un metodo, bloccherà l'oggetto (un thread può accedere a un oggetto alla volta) ma se utilizziamo static sincronizzato, bloccherà una classe (un thread può accedere a una classe alla volta). Più dettagli.

25)Qual è la differenza tra notify() e notifyAll()?

Notify() viene utilizzato per sbloccare un thread in attesa mentre il metodo notifyAll() viene utilizzato per sbloccare tutti i thread in stato di attesa.

26) Qual è lo stallo?

Il deadlock è una situazione in cui ogni thread attende una risorsa trattenuta da qualche altro thread in attesa. In questa situazione, nessuno dei thread viene eseguito né ha la possibilità di essere eseguito. Esiste invece uno stato di attesa universale tra tutti i thread. Il deadlock è una situazione molto complicata che può rompere il nostro codice in fase di esecuzione.

27) Come rilevare una condizione di stallo? Come può essere evitato?

Possiamo rilevare la condizione di deadlock eseguendo il codice su cmd e raccogliendo il Thread Dump e, se nel codice è presente un deadlock, verrà visualizzato un messaggio su cmd.

costruttore in Java

Modi per evitare la condizione di stallo in Java:

Evita il blocco annidato:Il blocco nidificato è il motivo comune del deadlock poiché il deadlock si verifica quando forniamo blocchi a vari thread, quindi dovremmo dare un blocco a un solo thread alla volta.Evita serrature non necessarie:dobbiamo evitare le serrature che non sono necessarie.Utilizzo dell'unione di thread:Il thread join aiuta ad attendere un thread finché un altro thread non termina la sua esecuzione, in modo da poter evitare il deadlock utilizzando al massimo il metodo join.

28) Cos'è il Thread Scheduler in Java?

In Java, quando creiamo i thread, questi vengono supervisionati con l'aiuto di un Thread Scheduler, che fa parte di JVM. Lo scheduler dei thread è responsabile solo di decidere quale thread deve essere eseguito. Lo scheduler dei thread utilizza due meccanismi per la pianificazione dei thread: Preemptive e Time Slicing.

• Seleziona la priorità del thread.
• Determina il tempo di attesa per un thread
• Controlla la natura del thread

29) Ogni thread ha il proprio stack nella programmazione multithread?

Sì, nella programmazione multithread ogni thread mantiene in memoria la propria o separata area di stack grazie alla quale ogni thread è indipendente l'uno dall'altro.

30) Come si ottiene la sicurezza di un filo?

Se un metodo o un oggetto classe può essere utilizzato da più thread contemporaneamente senza alcuna race condition, la classe è thread-safe. La sicurezza del thread viene utilizzata per rendere un programma sicuro da utilizzare nella programmazione multithread. Può essere raggiunto nei seguenti modi:

• Sincronizzazione
• Utilizzando la parola chiave volatile
• Utilizzando un meccanismo basato su blocco
• Uso delle classi wrapper atomiche

31) Cos'è la condizione di gara?

Una Race Condition è un problema che si verifica nella programmazione multithread quando più thread vengono eseguiti contemporaneamente accedendo contemporaneamente ad una risorsa condivisa. L'uso corretto della sincronizzazione può evitare la condizione di gara.

32) Qual è la parola chiave volatile in Java?

La parola chiave volatile viene utilizzata nella programmazione multithread per ottenere la sicurezza del thread, poiché una modifica in una variabile volatile è visibile a tutti gli altri thread in modo che una variabile possa essere utilizzata da un thread alla volta.

33) Cosa intendi per pool di thread?

• Il pool di thread Java rappresenta un gruppo di thread di lavoro in attesa dell'allocazione dell'attività.
• I thread nel pool di thread sono supervisionati dal fornitore di servizi che estrae un thread dal pool e gli assegna un lavoro.
• Dopo il completamento dell'attività specificata, il thread è arrivato nuovamente al pool di thread.
• La dimensione del pool di thread dipende dal numero totale di thread mantenuti in riserva per l'esecuzione.

I vantaggi del pool di thread sono:

• Utilizzando un pool di thread, è possibile migliorare le prestazioni.
• Utilizzando un pool di thread, è possibile ottenere una migliore stabilità del sistema.

Domande per l'intervista sulla concorrenza

34) Quali sono i componenti principali dell'API di concorrenza?

L'API di concorrenza può essere sviluppata utilizzando la classe e le interfacce del pacchetto java.util.Concurrent. Nel pacchetto java.util.Concurrent sono presenti le seguenti classi e interfacce.

• Esecutore
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Futuro
• Unità di tempo(Enum)
• Conteggio alla rovescia
• Barriera ciclica
• Semaforo
• ThreadFactory
• BlockingQueue
• DelayQueue
• Serrature
• Faser

35) Qual è l'interfaccia dell'Executor nell'API Concurrency in Java?

L'interfaccia dell'esecutore fornita dal pacchetto java.util.concurrent è la semplice interfaccia utilizzata per eseguire la nuova attività. Il metodoexecute() dell'interfaccia Executor viene utilizzato per eseguire un determinato comando. Di seguito è riportata la sintassi del metodoexecute().

void eseguite (comando eseguibile)

Considera il seguente esempio:

 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(); } } } } 

Produzione

 Running Thread! Thread Completed 

36) Cos'è BlockingQueue?

java.util.concurrent.BlockingQueue è la sottointerfaccia di Queue che supporta operazioni come l'attesa della disponibilità di spazio prima di inserire un nuovo valore o l'attesa che la coda diventi non vuota prima di recuperare un elemento da essa. Considera il seguente esempio.

 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(); } } } } 

Produzione

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

37) Come implementare il problema produttore-consumatore utilizzando BlockingQueue?

Il problema produttore-consumatore può essere risolto utilizzando BlockingQueue nel modo seguente.

 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 è la differenza tra l'interfaccia Java Callable e l'interfaccia Runnable?

Sia l'interfaccia Callable che l'interfaccia Runnable vengono utilizzate dalle classi che desiderano essere eseguite con più thread. Tuttavia, ci sono due differenze principali tra i due:

• Un'interfaccia Callable può restituire un risultato, mentre l'interfaccia Runnable non può restituire alcun risultato.
• Un'interfaccia Callable può generare un'eccezione controllata, mentre l'interfaccia Runnable non può generare un'eccezione controllata.
• Un'interfaccia Callable non può essere utilizzata prima di Java 5 mentre è possibile utilizzare l'interfaccia Runnable.

39) Cos'è l'azione atomica in concorrenza in Java?

• L'azione atomica è l'operazione che può essere eseguita in una singola unità di un compito senza alcuna interferenza con le altre operazioni.
• L'azione Atomica non può essere interrotta tra un'attività e l'altra. Una volta avviato, il riempimento si interrompe solo dopo il completamento dell'attività.
• Un'operazione di incremento come a++ non consente un'azione atomica.
• Tutte le operazioni di lettura e scrittura per la variabile primitiva (eccetto long e double) sono operazioni atomiche.
• Tutte le operazioni di lettura e scrittura per la variabile volatile (inclusi long e double) sono operazioni atomiche.
• I metodi Atomic sono disponibili nel pacchetto java.util.Concurrent.

40) Cos'è l'interfaccia di blocco nell'API Concurrency in Java?

L'interfaccia java.util.concurrent.locks.Lock viene utilizzata come meccanismo di sincronizzazione. Funziona in modo simile al blocco sincronizzato. Di seguito sono riportate alcune differenze tra il blocco e il blocco sincronizzato.

• L'interfaccia di blocco fornisce la garanzia della sequenza in cui verrà concesso l'accesso al thread in attesa, mentre il blocco sincronizzato non lo garantisce.
• L'interfaccia di blocco fornisce l'opzione di timeout se il blocco non viene concesso, mentre il blocco sincronizzato non lo fornisce.
• I metodi dell'interfaccia Lock, ovvero Lock() e Unlock() possono essere chiamati in metodi diversi mentre il singolo blocco sincronizzato deve essere completamente contenuto in un singolo metodo.

41) Spiegare l'interfaccia ExecutorService.

L'interfaccia ExecutorService è la sottointerfaccia dell'interfaccia Executor e aggiunge le funzionalità per gestire il ciclo di vita. Considera il seguente esempio.

 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(); } } } } 

Produzione

 Shutdown executor shutdown finished 

42) Qual è la differenza tra programmazione sincrona e programmazione asincrona riguardo ad un thread?

Programmazione sincrona: Nel modello di programmazione sincrona, a un thread viene assegnato il compito di completare un'attività e quindi il thread inizia a lavorarci sopra, ed è disponibile per altre attività solo una volta terminata l'attività assegnata.

Programmazione asincrona: Nella programmazione asincrona, un lavoro può essere completato da più thread e quindi fornisce la massima usabilità dei vari thread.

43) Cosa intendi per Callable e Future in Java?

Interfaccia richiamabile Java: In Java5 l'interfaccia richiamabile era fornita dal pacchetto java.util.concurrent. È simile all'interfaccia Runnable ma può restituire un risultato e lanciare un'eccezione. Fornisce inoltre un metodo run() per l'esecuzione di un thread. Java Callable può restituire qualsiasi oggetto poiché utilizza Generic.

Sintassi:

interfaccia pubblica richiamabile

Interfaccia Java futura: L'interfaccia Java Future fornisce il risultato di un processo simultaneo. L'interfaccia Callable restituisce l'oggetto di java.util.concurrent.Future.

Java Future fornisce i seguenti metodi per l'implementazione.

cancel(booleano�mayInterruptIfRunning):Viene utilizzato per annullare l'esecuzione dell'attività assegnata.Ottenere():Attende il momento in cui l'esecuzione non viene completata e quindi recupera il risultato.èCancellato():Restituisce il valore booleano poiché restituisce true se l'attività è stata annullata prima del completamento.è fatta():Restituisce vero se il lavoro è stato completato con successo altrimenti restituisce falso.

44. Qual è la differenza tra l'interfaccia ScheduledExecutorService e ExecutorService?

ExecutorServcie e ScheduledExecutorService sono entrambe le interfacce del pacchetto java.util.Concurrent ma scheduledExecutorService fornisce alcuni metodi aggiuntivi per eseguire le attività Runnable e Callable con il ritardo o ogni periodo di tempo fisso.

45) Definire la classe FutureTask in Java?

La classe Java FutureTask fornisce un'implementazione di base dell'interfaccia Future. Il risultato può essere ottenuto solo se l'esecuzione di un'attività viene completata e se il calcolo non viene completato, il metodo get verrà bloccato. Se l'esecuzione è completata, non può essere riavviata né annullata.

metodi Java

Sintassi

la classe pubblica FutureTask estende l'oggetto implementa RunnableFuture