Multithreadingul și Sincronizarea sunt considerate ca fiind capitolul tipic în programarea java. În companiile de dezvoltare de jocuri, întrebările de interviu legate de multithreading sunt adresate în mare parte. Mai jos este prezentată o listă cu întrebări frecvente pentru interviu multithreading java și simultan.

Întrebări de interviu multithreading

1) Ce este multithreading-ul?

Multithreading este un proces de executare a mai multor fire simultan. Multithreading este folosit pentru a obține multitasking. Consumă mai puțină memorie și oferă performanță rapidă și eficientă. Principalele sale avantaje sunt:

• Threadurile au același spațiu de adrese.
• Firul este ușor.
• Costul de comunicare între procese este scăzut.

2) Care este firul?

Un fir este un subproces ușor. Este o cale separată de execuție, deoarece fiecare fir rulează într-un cadru de stivă diferit. Un proces poate conține mai multe fire. Threadurile partajează resursele procesului, dar totuși se execută independent.

3) Faceți diferența între proces și fir?

Există următoarele diferențe între proces și fir.

• Un program în execuție se numește proces în timp ce; Un fir este un subset al procesului
• Procesele sunt independente, în timp ce firele sunt subsetul procesului.
• Procesul are spațiu de adrese diferit în memorie, în timp ce firele de execuție conțin un spațiu de adrese partajat.
• Comutarea contextului este mai rapidă între fire în comparație cu procese.
• Comunicarea între procese este mai lentă și mai costisitoare decât comunicarea între fire.
• Orice modificare în procesul părinte nu afectează procesul copil, în timp ce modificările în firul părinte pot afecta firul copil.

4) Ce înțelegeți prin comunicare inter-thread?

• Procesul de comunicare între firele sincronizate este denumit comunicare între fire.
• Comunicarea între fire este folosită pentru a evita interogarea firelor în Java.
• Firul este întrerupt în rularea în secțiunea sa critică, iar un alt fir are voie să intre (sau să se blocheze) în aceeași secțiune critică pentru a fi executat.
• Poate fi obținut prin metodele wait(), notify() și notifyAll().

5) Care este scopul metodei wait() în Java?

Metoda wait() este furnizată de clasa Object în Java. Această metodă este folosită pentru comunicarea inter-thread în Java. Java.lang.Object.wait() este folosit pentru a întrerupe firul curent și pentru a aștepta până când un alt fir nu apelează metoda notify() sau notifyAll(). Sintaxa sa este prezentată mai jos.

public final nul așteptare()

6) De ce trebuie apelată metoda wait() din blocul sincronizat?

Trebuie să apelăm la metoda de așteptare, altfel va arunca java.lang.IllegalMonitorStateException excepție. Mai mult, avem nevoie de metoda wait() pentru comunicarea inter-thread cu notify() și notifyAll(). Prin urmare, trebuie să fie prezent în blocul sincronizat pentru o comunicare corectă și corectă.

7) Care sunt avantajele multithreading-ului?

Programarea multithreading are următoarele avantaje:

• Multithreading permite unei aplicații/program să fie întotdeauna reactiv pentru intrare, chiar și rulând deja cu unele sarcini de fundal
• Multithreading permite executarea mai rapidă a sarcinilor, deoarece firele de execuție se execută independent.
• Multithreading oferă o mai bună utilizare a memoriei cache, deoarece firele de execuție împart resursele comune de memorie.
• Multithreading reduce numărul de servere necesare, deoarece un server poate executa mai multe fire de execuție simultan.

8) Care sunt stările din ciclul de viață al unui Thread?

Un thread poate avea una dintre următoarele stări pe durata de viață:

Nou:În această stare, un obiect de clasă Thread este creat folosind un operator nou, dar firul de execuție nu este activ. Thread-ul nu începe până când nu apelăm metoda start().Rugabil:În această stare, firul de execuție este gata să ruleze după apelarea metodei start(). Cu toate acestea, firul de execuție nu este încă selectat de planificatorul de fire.Alergare:În această stare, programatorul de fire de execuție alege firul de execuție din starea gata, iar firul de execuție rulează.În așteptare/Blocat:În această stare, un fir de execuție nu rulează, dar este încă viu sau așteaptă ca celălalt thread să se termine.Mort/Terminat:Un fir de execuție este în stare terminată sau mort când metoda run() iese.

9) Care este diferența dintre programarea preventivă și time slicing?

În cadrul programării preventive, sarcina cu cea mai mare prioritate se execută până când intră în stările de așteptare sau mort sau ia naștere o sarcină cu prioritate mai mare. În timpul tăierii în timp, o sarcină se execută pentru o porțiune de timp predefinită și apoi reintră în grupul de sarcini gata. Planificatorul determină apoi ce sarcină trebuie executată în continuare, pe baza priorității și a altor factori.

10) Ce este schimbarea contextului?

În schimbarea contextului, starea procesului (sau firului de execuție) este stocată astfel încât să poată fi restaurată și execuția să poată fi reluată din același punct ulterior. Comutarea contextului permite mai multor procese să partajeze același procesor.

11) Faceți diferența între clasa Thread și interfața Runnable pentru crearea unui Thread?

Thread-ul poate fi creat folosind două moduri.

• Prin extinderea clasei Thread
• Prin implementarea interfeței Runnable

Cu toate acestea, diferențele principale dintre ambele moduri sunt prezentate mai jos:

• Prin extinderea clasei Thread, nu putem extinde nicio altă clasă, deoarece Java nu permite moșteniri multiple în timpul implementării interfeței Runnable; putem extinde și altă clasă de bază (dacă este necesar).
• Prin extinderea clasei Thread, fiecare thread creează obiectul unic și se asociază cu acesta în timp ce implementează interfața Runnable; mai multe fire împărtășesc același obiect
• Clasa Thread oferă diverse metode încorporate, cum ar fi getPriority(), isAlive și multe altele, în timp ce interfața Runnable oferă o singură metodă, adică run().

12) Ce înseamnă metoda join()?

Metoda join() așteaptă ca un fir să dispară. Cu alte cuvinte, face ca firele de execuție care rulează în prezent să se oprească până când firul cu care se alătură își finalizează sarcina. Metoda Join este supraîncărcată în clasa Thread în următoarele moduri.

• public void join() aruncă InterruptedException
• public void join (milisecunde lungi) aruncă InterruptedException

13) Descrieți scopul și funcționarea metodei sleep().

Metoda sleep() în java este folosită pentru a bloca un fir de execuție pentru un anumit timp, ceea ce înseamnă că întrerupe execuția unui fir pentru un anumit timp. Există două metode de a face acest lucru.

Sintaxă:

compara cu java

• Public static void sleep (milisecunde lungi) aruncă InterruptedException
• Public static void sleep (milisecunde lungi, int nanos) aruncă InterruptedException

Metoda de lucru a somnului ().

Când apelăm metoda sleep(), aceasta întrerupe execuția firului curent pentru timpul dat și dă prioritate unui alt fir (dacă este disponibil). Mai mult, atunci când timpul de așteptare s-a încheiat, apoi din nou firul anterior își schimbă starea de la așteptare la rulabil și intră în stare de rulare, iar întregul proces funcționează așa mai departe până când execuția nu se finalizează.

14) Care este diferența dintre metoda wait() și sleep()?

15) Este posibil să porniți un thread de două ori?

Nu, nu putem reporni firul de execuție, deoarece odată ce un fir de execuție a început și executat, acesta trece în starea Dead. Prin urmare, dacă încercăm să începem un fir de execuție de două ori, va da o excepție runtimeException 'java.lang.IllegalThreadStateException'. Luați în considerare următorul exemplu.

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

Ieșire

 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) Putem apela metoda run() în loc de start()?

Da, apelarea directă a metodei run() este validă, dar nu va funcționa ca un fir, ci va funcționa ca un obiect normal. Nu va exista comutare de context între fire. Când apelăm metoda start(), aceasta apelează intern metoda run(), care creează o nouă stivă pentru un fir de execuție, în timp ce apelând direct run() nu va crea o stivă nouă.

17) Dar firele de demon?

Firele de execuție demon sunt firele de execuție cu prioritate scăzută care oferă suport și servicii de fundal firelor de execuție ale utilizatorului. Firul Daemon este terminat automat de către JVM dacă programul rămâne doar cu firul Daemon și toate celelalte fire de execuție ale utilizatorului sunt încheiate/muritoare. Există două metode pentru firele de demon disponibile în clasa Thread:

public void setDaemon (starea booleană):Era folosit pentru a marca firul de execuție al demonului sau un fir de execuție.public boolean isDaemon():Verifică dacă firul este demon sau nu.

18) Putem face firul utilizatorului ca fire demon dacă firul este pornit?

Nu, dacă faceți acest lucru, va arunca IllegalThreadStateException. Prin urmare, putem crea doar un fir de execuție înainte de a începe firul.

boolean la șir java

 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. } } 

Ieșire

 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) Ce este cârligul de închidere?

Cârligul de închidere este un fir care este invocat implicit înainte ca JVM să se închidă. Deci îl putem folosi pentru a curăța resursa sau pentru a salva starea când JVM se oprește în mod normal sau brusc. Putem adăuga un cârlig de închidere utilizând următoarea metodă:

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

Câteva puncte importante despre cârligele de închidere sunt:

• Cârligele de închidere au fost inițializate, dar pot fi pornite numai când a avut loc oprirea JVM.
• Cârligele de închidere sunt mai fiabile decât finalizer() deoarece există foarte puține șanse ca cârligele de închidere să nu ruleze.
• Cârligul de închidere poate fi oprit apelând metoda halt(int) a clasei Runtime.

20) Când ar trebui să întrerupem un fir?

Ar trebui să întrerupem un fir atunci când vrem să întrerupem starea de somn sau de așteptare a unui fir. Putem întrerupe un fir de execuție apelând interrupt()-aruncând InterruptedException.

21) Ce este sincronizarea?

Sincronizarea este capacitatea de a controla accesul mai multor fire de execuție la orice resursă partajată. Este folosit:

1. Pentru a preveni interferența firului.
2. Pentru a preveni problema de consistență.

Atunci când mai multe fire de execuție încearcă să facă aceeași sarcină, există posibilitatea unui rezultat eronat, prin urmare, pentru a elimina această problemă, Java utilizează procesul de sincronizare care permite executarea unui singur fir odată. Sincronizarea poate fi realizată în trei moduri:

• prin metoda sincronizată
• prin bloc sincronizat
• prin sincronizare statică

Sintaxă pentru blocul sincronizat

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

22) Care este scopul blocului Sincronizat?

Blocul Sincronizat poate fi folosit pentru a efectua sincronizarea pe orice resursă specifică a metodei. Doar un fir de execuție la un moment dat se poate executa pe o anumită resursă, iar toate celelalte fire care încearcă să intre în blocul sincronizat sunt blocate.

• Blocul sincronizat este folosit pentru a bloca un obiect pentru orice resursă partajată.
• Sfera de aplicare a blocului sincronizat este limitată la blocul pe care se aplică. Domeniul său de aplicare este mai mic decât o metodă.

23) Poate fi blocat obiectul Java pentru utilizare exclusivă de către un anumit thread?

Da. Puteți bloca un obiect punându-l într-un bloc „sincronizat”. Obiectul blocat este inaccesibil pentru orice fir altul decât cel care l-a revendicat în mod explicit.

24) Ce este sincronizarea statică?

Dacă faceți ca orice metodă statică să fie sincronizată, blocarea va fi pe clasă, nu pe obiect. Dacă folosim cuvântul cheie synchronized înainte de o metodă, astfel va bloca obiectul (un fir poate accesa un obiect la un moment dat), dar dacă folosim sincronizat static, va bloca o clasă (un fir poate accesa o clasă la un moment dat). Mai multe detalii.

marca html

25) Care este diferența dintre notify() și notifyAll()?

Notify() este folosit pentru a debloca un fir de execuție în așteptare, în timp ce metoda notifyAll() este folosită pentru a debloca toate firele de execuție în starea de așteptare.

26) Ce este impasul?

Deadlock este o situație în care fiecare fir așteaptă o resursă care este deținută de un alt fir în așteptare. În această situație, niciun fir nu se execută și nici nu are șansa de a fi executat. În schimb, există o stare de așteptare universală printre toate firele. Deadlock este o situație foarte complicată care poate rupe codul nostru în timpul execuției.

27) Cum se detectează o condiție de blocaj? Cum poate fi evitat?

Putem detecta starea de deadlock rulând codul pe cmd și colectând Thread Dump, iar dacă există vreun deadlock în cod, atunci va apărea un mesaj pe cmd.

Modalități de a evita starea de blocaj în Java:

Evitați blocarea imbricată:Blocarea imbricată este motivul obișnuit al blocajului, deoarece blocarea apare atunci când furnizăm blocări diferitelor fire, așa că ar trebui să acordăm o blocare doar unui singur fir la un moment dat.Evitați încuietorile inutile:trebuie să evităm încuietorile care nu sunt necesare.Folosind îmbinarea firelor:Asocierea firului de execuție ajută la așteptarea unui fir de execuție până când un alt fir de execuție nu își termină execuția, astfel încât să putem evita blocajul prin utilizarea maximă a metodei de unire.

28) Ce este Thread Scheduler în java?

În Java, când creăm firele, acestea sunt supravegheate cu ajutorul unui Thread Scheduler, care face parte din JVM. Planificatorul de fire este responsabil doar pentru a decide ce fir trebuie executat. Programatorul de fire folosește două mecanisme pentru programarea firelor: Preemptive și Time Slicing.

• Selectează prioritatea firului.
• Determină timpul de așteptare pentru un fir
• Verifică natura firului

29) Fiecare thread are stiva sa în programare multithreaded?

Da, în programarea cu mai multe fire de execuție fiecare fir își menține în memorie o zonă de stivă proprie sau separată, datorită căreia fiecare fir de execuție este independent unul de celălalt.

30) Cum se obține siguranța unui fir?

Dacă o metodă sau un obiect de clasă poate fi folosit de mai multe fire simultan fără nicio condiție de cursă, atunci clasa este sigură pentru fire. Siguranța firelor este utilizată pentru a face un program sigur de utilizat în programarea cu mai multe fire. Se poate realiza prin următoarele moduri:

• Sincronizare
• Folosind cuvântul cheie Volatil
• Folosind un mecanism bazat pe blocare
• Utilizarea claselor de înveliș atomic

31) Ce este condiția de rasă?

O condiție de cursă este o problemă care apare în programarea cu mai multe fire atunci când se execută mai multe fire de execuție accesând simultan o resursă partajată în același timp. Utilizarea corectă a sincronizării poate evita condiția de cursă.

32) Care este cuvântul cheie volatil în java?

Cuvântul cheie volatil este folosit în programarea cu mai multe fire pentru a obține siguranța firului, deoarece o modificare a unei variabile volatile este vizibilă pentru toate celelalte fire, astfel încât o variabilă poate fi utilizată de un fir la un moment dat.

33) Ce înțelegeți prin grup de fire?

• Pool Thread Java reprezintă un grup de fire de lucru care așteaptă ca sarcina să fie alocată.
• Firele din grupul de fire sunt supravegheate de furnizorul de servicii, care extrage un fir din pool și îi atribuie un job.
• După finalizarea sarcinii date, threadul a ajuns din nou la pool-ul de fire.
• Mărimea pool-ului de fire depinde de numărul total de fire păstrate în rezervă pentru execuție.

Avantajele pool-ului de fire sunt:

• Folosind un pool de fire, performanța poate fi îmbunătățită.
• Folosind un pool de fire, poate apărea o mai bună stabilitate a sistemului.

Întrebări de interviu simultan

34) Care sunt principalele componente ale API-ului de concurență?

Concurrency API poate fi dezvoltat folosind clasa și interfețele pachetului java.util.Concurrent. Există următoarele clase și interfețe în pachetul java.util.Concurrent.

• Executor testamentar
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Viitor
• TimeUnit(Enum)
• CountdownLatch
• CyclicBarrier
• Semafor
• ThreadFactory
• BlockingQueue
• DelayQueue
• Încuietori
• Phaser

35) Ce este interfața Executor în Concurrency API în Java?

Interfața Executor furnizată de pachetul java.util.concurrent este interfața simplă folosită pentru a executa noua sarcină. Metoda execute() a interfeței Executor este folosită pentru a executa o comandă dată. Sintaxa metodei execute() este dată mai jos.

void execute (comandă rulabilă)

Luați în considerare următorul exemplu:

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

Ieșire

 Running Thread! Thread Completed 

36) Ce este BlockingQueue?

java.util.concurrent.BlockingQueue este subinterfața Cozii care acceptă operațiuni precum așteptarea disponibilității spațiului înainte de a introduce o nouă valoare sau așteptarea ca coada să devină negoală înainte de a prelua un element din ea. Luați în considerare următorul exemplu.

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

Ieșire

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

37) Cum se implementează problema producător-consumator utilizând BlockingQueue?

Problema producător-consumator poate fi rezolvată folosind BlockingQueue în felul următor.

 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) Care este diferența dintre interfața Java Callable și interfața Runnable?

Interfața Callable și interfața Runnable sunt folosite de clasele care au dorit să se execute cu mai multe fire. Cu toate acestea, există două diferențe principale între ambele:

• O interfață Callable poate returna un rezultat, în timp ce interfața Runnable nu poate returna niciun rezultat.
• O interfață Callable poate arunca o excepție bifată, în timp ce interfața Runnable nu poate arunca o excepție bifată.
• O interfață apelabilă nu poate fi utilizată înainte de Java 5, în timp ce interfața Runnable poate fi utilizată.

39) Care este acțiunea atomică în concurență în Java?

• Acțiunea atomică este operația care poate fi efectuată într-o singură unitate a unei sarcini fără nicio interferență a celorlalte operații.
• Acțiunea atomică nu poate fi oprită între sarcini. Odată pornit, se oprește numai după finalizarea sarcinii.
• O operație de creștere, cum ar fi a++, nu permite o acțiune atomică.
• Toate operațiile de citire și scriere pentru variabila primitivă (cu excepția lungi și duble) sunt operația atomică.
• Toate operațiunile de citire și scriere pentru variabila volatilă (inclusiv long și double) sunt operația atomică.
• Metodele atomice sunt disponibile în pachetul java.util.Concurrent.

40) Ce este interfața de blocare în Concurrency API în Java?

Interfața java.util.concurrent.locks.Lock este folosită ca mecanism de sincronizare. Funcționează similar cu blocul sincronizat. Există câteva diferențe între blocarea și blocul sincronizat care sunt prezentate mai jos.

• Interfața de blocare oferă garanția secvenței în care firul în așteptare va primi acces, în timp ce blocul sincronizat nu îl garantează.
• Interfața de blocare oferă opțiunea de expirare dacă blocarea nu este acordată, în timp ce blocul sincronizat nu oferă acest lucru.
• Metodele interfeței Lock, adică Lock() și Unlock() pot fi apelate în diferite metode, în timp ce un singur bloc sincronizat trebuie să fie complet cuprins într-o singură metodă.

41) Explicați interfața ExecutorService.

Interfața ExecutorService este subinterfața interfeței Executor și adaugă funcții pentru a gestiona ciclul de viață. Luați în considerare următorul exemplu.

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

Ieșire

 Shutdown executor shutdown finished 

42) Care este diferența dintre programarea sincronă și programarea asincronă în ceea ce privește un fir?

Programare sincrona: În modelul de programare sincronă, un fir de execuție este alocat pentru a finaliza o sarcină și, prin urmare, firul de execuție a început să lucreze la el și este disponibil numai pentru alte sarcini odată ce va termina sarcina alocată.

Programare asincronă: În programarea asincronă, o lucrare poate fi finalizată cu mai multe fire și, prin urmare, oferă o utilizare maximă a diferitelor fire.

43) Ce înțelegeți prin Callable și Future în Java?

Interfață apelabilă Java: În Java5, interfața apelabilă a fost furnizată de pachetul java.util.concurrent. Este similar cu interfața Runnable, dar poate returna un rezultat și poate arunca o excepție. De asemenea, oferă o metodă run() pentru execuția unui fir. Java Callable poate returna orice obiect deoarece folosește generic.

Sintaxă:

interfață publică Apelabilă

Interfață Java Future: Interfața Java Future oferă rezultatul unui proces concurent. Interfața Callable returnează obiectul java.util.concurrent.Future.

bou vs taur

Java Future oferă următoarele metode de implementare.

cancel(boolean�mayInterruptIfRunning):Este folosit pentru a anula execuția sarcinii atribuite.obține():Așteaptă timpul dacă execuția nu s-a încheiat și apoi a preluat rezultatul.este anulat():Returnează valoarea booleană, deoarece returnează adevărat dacă sarcina a fost anulată înainte de finalizare.este gata():Returnează adevărat dacă lucrarea este finalizată cu succes, altfel returnează false.

44. Care este diferența dintre interfața ScheduledExecutorService și ExecutorService?

ExecutorServcie și ScheduledExecutorService sunt ambele interfețe ale pachetului java.util.Concurrent, dar scheduledExecutorService oferă câteva metode suplimentare pentru a executa sarcinile Runnable și Callable cu întârziere sau în fiecare perioadă de timp fixă.

45) Definiți clasa FutureTask în Java?

Clasa Java FutureTask oferă o implementare de bază a interfeței Future. Rezultatul poate fi obținut numai dacă execuția unei sarcini este finalizată, iar dacă calculul nu este realizat, metoda get va fi blocată. Dacă execuția este finalizată, atunci nu poate fi repornită și nu poate fi anulată.

Sintaxă

clasa publică FutureTask extinde Object implementează RunnableFuture