Daudzpavedienu izveide un sinhronizācija tiek uzskatīta par tipisku java programmēšanas nodaļu. Spēļu izstrādes uzņēmumos pārsvarā tiek uzdoti ar daudzpavedienu saistīti interviju jautājumi. Tālāk ir sniegts bieži uzdoto java daudzpavedienu un vienlaicīgu intervijas jautājumu saraksts.

Daudzpavedienu intervijas jautājumi

1) Kas ir daudzpavedienu veidošana?

Vairāku pavedienu veidošana ir process, kurā vienlaikus tiek izpildīti vairāki pavedieni. Daudzpavedienu izmantošana tiek izmantota, lai iegūtu vairākuzdevumu izpildi. Tas patērē mazāk atmiņas un nodrošina ātru un efektīvu veiktspēju. Tās galvenās priekšrocības ir:

• Pavedieniem ir viena adrešu telpa.
• Vītne ir viegla.
• Saziņas izmaksas starp procesiem ir zemas.

2) Kas ir pavediens?

Vītne ir viegls apakšprocess. Tas ir atsevišķs izpildes ceļš, jo katrs pavediens darbojas citā steka kadrā. Procesā var būt vairāki pavedieni. Pavedieni koplieto procesa resursus, bet tomēr tie tiek izpildīti neatkarīgi.

3) Atšķirt procesu un pavedienu?

Starp procesu un pavedienu ir šādas atšķirības.

• Programmu izpildē sauc par procesu, turpretim; Pavediens ir procesa apakškopa
• Procesi ir neatkarīgi, savukārt pavedieni ir procesa apakškopa.
• Procesam ir atšķirīga adrešu telpa atmiņā, savukārt pavedieni satur koplietotu adrešu telpu.
• Salīdzinot ar procesiem, konteksta pārslēgšana starp pavedieniem ir ātrāka.
• Starpprocesu komunikācija ir lēnāka un dārgāka nekā komunikācija starp pavedieniem.
• Jebkuras izmaiņas vecāku procesā neietekmē pakārtoto procesu, turpretim izmaiņas vecākajā pavedienā var ietekmēt pakārtoto pavedienu.

4) Ko jūs saprotat ar starppavedienu komunikāciju?

• Saziņas process starp sinhronizētiem pavedieniem tiek saukts par starppavedienu komunikāciju.
• Saziņa starp pavedieniem tiek izmantota, lai izvairītos no pavedienu aptaujas Java.
• Pavediens tiek apturēts tā kritiskajā sadaļā, un citam pavedienam ir atļauts ienākt (vai bloķēt) tajā pašā kritiskajā sadaļā, lai tas tiktu izpildīts.
• To var iegūt, izmantojot gaidīšanas (), notify () un notifyAll () metodes.

5) Kāds ir gaidīšanas () metodes mērķis Java?

Waites () metodi nodrošina Java Object klase. Šī metode tiek izmantota starppavedienu saziņai Java. Java.lang.Object.wait() tiek izmantots, lai apturētu pašreizējo pavedienu un gaidītu, līdz cits pavediens neizsauc notify() vai notifyAll() metodi. Tās sintakse ir norādīta zemāk.

publiska galīgā tukša gaidīšana ()

6) Kāpēc no sinhronizētā bloka jāizsauc metode wait()?

Mums ir jāizsauc gaidīšanas metode, pretējā gadījumā tas izmetīs java.lang.IllegalMonitorStateException izņēmums. Turklāt mums ir nepieciešama gaidīšanas () metode starppavedienu saziņai ar notify () un notifyAll (). Tāpēc tam jābūt klāt sinhronizētajā blokā, lai nodrošinātu pareizu un pareizu saziņu.

7) Kādas ir daudzpavedienu priekšrocības?

Daudzpavedienu programmēšanai ir šādas priekšrocības:

• Daudzpavedienu izmantošana ļauj lietojumprogrammai/programmai vienmēr būt aktīvai ievadei, pat ja tā jau darbojas ar dažiem fona uzdevumiem
• Daudzpavedienu izmantošana ļauj ātrāk izpildīt uzdevumus, jo pavedieni tiek izpildīti neatkarīgi.
• Daudzpavedienu izmantošana nodrošina labāku kešatmiņas izmantošanu, jo pavedieni koplieto kopējos atmiņas resursus.
• Daudzpavedienu izmantošana samazina vajadzīgā servera skaitu, jo viens serveris vienlaikus var izpildīt vairākus pavedienus.

8) Kādi stāvokļi ir pavediena dzīves ciklā?

Vītnei tā dzīves laikā var būt kāds no šiem stāvokļiem:

Jaunums:Šajā stāvoklī Thread klases objekts tiek izveidots, izmantojot jaunu operatoru, bet pavediens nav dzīvs. Pavediens nesākas, kamēr mēs neizsaucam start() metodi.Darbināms:Šajā stāvoklī pavediens ir gatavs darbībai pēc start() metodes izsaukšanas. Tomēr pavedienu plānotājs vēl nav atlasījis pavedienu.Skriešana:Šajā stāvoklī pavedienu plānotājs atlasa pavedienu no gatavības stāvokļa, un pavediens darbojas.Gaida/bloķēts:Šajā stāvoklī pavediens nedarbojas, bet joprojām ir dzīvs, vai arī tas gaida, kamēr otrs pavediens beigsies.Miris/beigts:Pavediens ir izbeigtā vai nedzīvā stāvoklī, kad tiek izieta metode run ().

9) Kāda ir atšķirība starp iepriekšēju plānošanu un laika sadalījumu?

Izmantojot iepriekšēju plānošanu, augstākās prioritātes uzdevums tiek izpildīts, līdz tas nonāk gaidīšanas vai izbeigšanās stāvokļos vai tiek izveidots augstākas prioritātes uzdevums. Laika griezumā uzdevums tiek izpildīts iepriekš noteiktu laika posmu un pēc tam atkārtoti ievada gatavu uzdevumu kopu. Pēc tam plānotājs nosaka, kurš uzdevums jāizpilda nākamais, pamatojoties uz prioritāti un citiem faktoriem.

10) Kas ir konteksta maiņa?

Konteksta pārslēgšanā procesa (vai pavediena) stāvoklis tiek saglabāts, lai to varētu atjaunot un vēlāk varētu atsākt izpildi no tā paša punkta. Konteksta maiņa ļauj vairākiem procesiem koplietot vienu un to pašu centrālo procesoru.

11) Atšķirt Thread klasi un Runnable interfeisu, lai izveidotu pavedienu?

Pavedienu var izveidot, izmantojot divus veidus.

• Paplašinot pavedienu klasi
• Ieviešot Runnable saskarni

Tomēr galvenās atšķirības starp abiem veidiem ir norādītas zemāk:

• Paplašinot Thread klasi, mēs nevaram paplašināt nevienu citu klasi, jo Java, ieviešot Runnable saskarni, nepieļauj vairākas mantošanas; mēs varam paplašināt arī citu bāzes klasi (ja nepieciešams).
• Paplašinot Thread klasi, katrs pavediens izveido unikālo objektu un saistās ar to, ieviešot Runnable interfeisu; vairākiem pavedieniem ir viens un tas pats objekts
• Pavedienu klase nodrošina dažādas iebūvētas metodes, piemēram, getPriority (), isAlive un daudzas citas, savukārt Runnable saskarne nodrošina vienu metodi, t.i., palaist ().

12) Ko nozīmē join() metode?

Join() metode gaida, līdz pavediens nomirst. Citiem vārdiem sakot, tas liek pašlaik palaistajiem pavedieniem apturēt izpildi, līdz pavediens, ar kuru tas pievienojas, pabeidz savu uzdevumu. Pievienošanās metode ir pārslogota Thread klasē šādos veidos.

• public void join()throws InterruptedException
• public void pievienoties(garas milisekundes) met InterruptedException

13) Aprakstiet miega() metodes mērķi un darbību.

Sleep() metode Java tiek izmantota, lai bloķētu pavedienu uz noteiktu laiku, kas nozīmē, ka tā uz noteiktu laiku aptur pavediena izpildi. Ir divas metodes, kā to izdarīt.

Sintakse:

bash lasīšanas fails

• publisks statisks tukšums miegs (garas milisekundes) met InterruptedException
• publisks statisks tukšais miegs (garas milisekundes, int nanos) met InterruptedException

Miega() metodes darbība

Izsaucot miega () metodi, tā uz noteiktu laiku aptur pašreizējā pavediena izpildi un piešķir prioritāti citam pavedienam (ja tāda ir pieejama). Turklāt, kad gaidīšanas laiks ir pabeigts, iepriekšējais pavediens maina savu stāvokli no gaidīšanas uz izpildāmu un nonāk darbības stāvoklī, un viss process darbojas tā tālāk, līdz izpilde netiek pabeigta.

14) Kāda ir atšķirība starp gaidīšanas () un miega () metodi?

15) Vai pavedienu var sākt divreiz?

Nē, mēs nevaram restartēt pavedienu, jo, tiklīdz pavediens ir palaists un izpildīts, tas pāriet uz mirušo stāvokli. Tāpēc, ja mēģināsim sākt pavedienu divreiz, tas dos izpildlaika izņēmumu 'java.lang.IllegalThreadStateException'. Apsveriet šādu piemēru.

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

Izvade

 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) Vai start() vietā var izsaukt run() metodi?

Jā, metodes run() tieša izsaukšana ir derīga, taču tā nedarbosies kā pavediens, tā darbosies kā parasts objekts. Starp pavedieniem nenotiks konteksta maiņa. Kad mēs izsaucam start() metodi, tā iekšēji izsauc run() metodi, kas pavedienam izveido jaunu steku, savukārt, tieši izsaucot run(), jaunu steku neradīs.

17) Kā ir ar dēmonu pavedieniem?

Dēmona pavedieni ir zemas prioritātes pavedieni, kas nodrošina fona atbalstu un pakalpojumus lietotāju pavedieniem. JVM automātiski pārtrauc dēmona pavedienu, ja programma paliek tikai ar dēmona pavedienu un visi pārējie lietotāju pavedieni ir beigušies/nomiruši. Pavedienu klasē ir pieejamas divas dēmona pavediena metodes:

public void setDaemon (būla statuss):To izmantoja, lai atzīmētu pavedienu dēmona pavedienu vai lietotāja pavedienu.publiskais Būla isDaemon():Tas pārbauda, ​​vai pavediens ir dēmons vai nē.

18) Vai mēs varam padarīt lietotāja pavedienu par dēmona pavedienu, ja pavediens tiek palaists?

Nē, ja jūs to darīsit, tiks parādīts IllegalThreadStateException. Tāpēc mēs varam izveidot dēmona pavedienu tikai pirms pavediena uzsākšanas.

iebilst pret json 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. } } 

Izvade

 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) Kas ir izslēgšanas āķis?

Izslēgšanas āķis ir pavediens, kas tiek izsaukts netieši pirms JVM izslēgšanas. Tātad mēs varam to izmantot, lai veiktu resursa tīrīšanu vai saglabātu stāvokli, kad JVM parasti vai pēkšņi izslēdzas. Mēs varam pievienot izslēgšanas āķi, izmantojot šādu metodi:

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

Daži svarīgi punkti par izslēgšanas āķiem ir:

• Izslēgšanas āķi ir inicializēti, bet tos var palaist tikai tad, kad notika JVM izslēgšana.
• Izslēgšanas āķi ir uzticamāki nekā finalizer(), jo ir ļoti mazāka iespēja, ka izslēgšanas āķi nedarbosies.
• Izslēgšanas āķi var apturēt, izsaucot izpildlaika klases halt(int) metodi.

20) Kad mums jāpārtrauc pavediens?

Mums jāpārtrauc pavediens, ja vēlamies pārtraukt pavediena miega vai gaidīšanas stāvokli. Mēs varam pārtraukt pavedienu, izsaucot interrupt()�izmetot InterruptedException.

21) Kas ir sinhronizācija?

Sinhronizācija ir iespēja kontrolēt vairāku pavedienu piekļuvi jebkuram koplietotajam resursam. To lieto:

1. Lai novērstu pavedienu traucējumus.
2. Lai novērstu konsekvences problēmu.

Kad vairāki pavedieni mēģina veikt vienu un to pašu uzdevumu, pastāv kļūdaina rezultāta iespēja, tāpēc, lai novērstu šo problēmu, Java izmanto sinhronizācijas procesu, kas ļauj vienlaikus izpildīt tikai vienu pavedienu. Sinhronizāciju var veikt trīs veidos:

• ar sinhronizētu metodi
• ar sinhronizētu bloku
• ar statisku sinhronizāciju

Sintakse sinhronizētam blokam

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

22) Kāds ir sinhronizētā bloka mērķis?

Sinhronizēto bloku var izmantot, lai veiktu sinhronizāciju jebkurā konkrētā metodes resursā. Tikai viens pavediens vienlaikus var tikt izpildīts noteiktā resursā, un visi pārējie pavedieni, kas mēģina iekļūt sinhronizētajā blokā, tiek bloķēti.

• Sinhronizētais bloks tiek izmantots, lai bloķētu objektu jebkuram koplietotajam resursam.
• Sinhronizētā bloka darbības joma ir ierobežota līdz blokam, kuram tas tiek lietots. Tās darbības joma ir mazāka nekā metode.

23) Vai Java objektu var bloķēt ekskluzīvai lietošanai noteiktā pavedienā?

Jā. Objektu var bloķēt, ievietojot to 'sinhronizētā' blokā. Bloķētais objekts nav pieejams nevienam citam pavedienam, izņemot to, kas uz to skaidri pretendēja.

24) Kas ir statiskā sinhronizācija?

Ja kādu statisko metodi padarīsit par sinhronizētu, bloķēšana būs klasē, nevis objektā. Ja mēs izmantojam sinhronizēto atslēgvārdu pirms metodes, tas bloķēs objektu (viens pavediens var piekļūt objektam vienlaikus), bet, ja mēs izmantojam statisko sinhronizāciju, tas bloķēs klasi (viens pavediens var piekļūt klasei vienlaikus). Skatīt vairāk.

25) Kāda ir atšķirība starp notify() un notifyAll()?

Notify () tiek izmantots, lai atbloķētu vienu gaidīšanas pavedienu, savukārt metode notifyAll () tiek izmantota, lai atbloķētu visus gaidīšanas stāvoklī esošus pavedienus.

26) Kas ir strupceļš?

Strupceļš ir situācija, kad katrs pavediens gaida resursu, ko aiztur kāds cits gaidīšanas pavediens. Šādā situācijā neviens pavediens netiek izpildīts, un tam nav iespējas tikt izpildītam. Tā vietā starp visiem pavedieniem pastāv universāls gaidīšanas stāvoklis. Strupceļš ir ļoti sarežģīta situācija, kas izpildes laikā var sabojāt mūsu kodu.

27) Kā noteikt strupceļa stāvokli? Kā no tā var izvairīties?

Mēs varam noteikt strupceļa stāvokli, palaižot kodu cmd un apkopojot pavedienu izdruku, un, ja kodā ir strupceļš, cmd tiks parādīts ziņojums.

Veidi, kā izvairīties no Java strupceļa stāvokļa:

Izvairieties no Nested bloķēšanas:Ligzdota bloķēšana ir izplatīts strupceļa iemesls, jo strupceļš rodas, ja mēs nodrošinām bloķēšanu dažādiem pavedieniem, tāpēc mums vajadzētu piešķirt vienu bloķēšanu tikai vienam pavedienam noteiktā laikā.Izvairieties no nevajadzīgām slēdzenēm:mums ir jāizvairās no slēdzenēm, kas nav vajadzīgas.Izmantojot pavedienu savienošanu:Pavedienu savienošana palīdz gaidīt pavedienu, līdz cits pavediens nepabeidz tā izpildi, lai mēs varētu izvairīties no strupceļa, maksimāli izmantojot savienošanas metodi.

28) Kas ir pavedienu plānotājs Java?

Java, kad mēs veidojam pavedienus, tie tiek uzraudzīti, izmantojot pavedienu plānotāju, kas ir JVM daļa. Pavedienu plānotājs ir atbildīgs tikai par izlemšanu, kurš pavediens ir jāizpilda. Pavedienu plānotājs izmanto divus pavedienu plānošanas mehānismus: Preemptive un Time Slicing.

• Tas izvēlas pavediena prioritāti.
• Tas nosaka pavediena gaidīšanas laiku
• Tas pārbauda pavediena raksturu

29) Vai daudzpavedienu programmēšanā katram pavedienam ir savs kaudze?

Jā, daudzpavedienu programmēšanā katrs pavediens saglabā savu vai atsevišķu steku apgabalu atmiņā, tāpēc katrs pavediens ir neatkarīgs viens no otra.

30) Kā tiek panākta vītnes drošība?

Ja metodi vai klases objektu var izmantot vairāki pavedieni vienlaikus bez jebkādiem sacensību nosacījumiem, tad klase ir droša pavedienam. Pavedienu drošība tiek izmantota, lai padarītu programmu drošu lietošanai daudzpavedienu programmēšanā. To var panākt šādos veidos:

• Sinhronizācija
• Izmantojot nepastāvīgu atslēgvārdu
• Izmantojot slēdzenes mehānismu
• Atomu iesaiņojuma klašu izmantošana

31) Kas ir rases stāvoklis?

Sacensību nosacījums ir problēma, kas rodas daudzpavedienu programmēšanā, kad dažādi pavedieni vienlaikus tiek izpildīti, vienlaikus piekļūstot koplietotajam resursam. Pareiza sinhronizācijas izmantošana var izvairīties no sacensību stāvokļa.

abstraktajai klasei var būt konstruktors

32) Kāds ir nepastāvīgais atslēgvārds Java?

Nepastāvīgs atslēgvārds tiek izmantots daudzpavedienu programmēšanā, lai panāktu pavedienu drošību, jo viena mainīgā mainīgā izmaiņas ir redzamas visiem pārējiem pavedieniem, tāpēc vienu mainīgo var izmantot viens pavediens vienlaikus.

33) Ko jūs saprotat ar pavedienu kopu?

• Java pavedienu pūls ir darbinieku pavedienu grupa, kas gaida, kad uzdevums tiks piešķirts.
• Pavedienus pavedienu pūlā uzrauga pakalpojumu sniedzējs, kas izvelk vienu pavedienu no kopas un piešķir tam darbu.
• Pēc dotā uzdevuma izpildes pavediens atkal nonāca pavedienu baseinā.
• Vītņu kopas lielums ir atkarīgs no izpildei rezervēto pavedienu kopskaita.

Vītņu baseina priekšrocības ir:

• Izmantojot pavedienu kopu, veiktspēju var uzlabot.
• Izmantojot pavedienu kopu, var nodrošināt labāku sistēmas stabilitāti.

Vienlaicības intervijas jautājumi

34) Kādi ir vienlaicīguma API galvenie komponenti?

Vienlaicības API var izstrādāt, izmantojot java.util.Concurrent pakotnes klasi un saskarnes. Pakotnē java.util.Concurrent ir šādas klases un saskarnes.

• Izpildītājs
• FarkJoinPool
• Izpildītāja pakalpojums
• ScheduledExecutorService
• Nākotne
• Laika vienība (Enum)
• CountDownLatch
• CyclicBarrier
• Semafors
• ThreadFactory
• Bloķēšanas rinda
• DelayQueue
• Slēdzenes
• Fāzers

35) Kas ir Java Concurrency API izpildītāja saskarne?

Izpildītāja saskarne, ko nodrošina pakotne java.util.concurrent, ir vienkārša saskarne, ko izmanto jaunā uzdevuma izpildei. Izpildītāja saskarnes metode execute() tiek izmantota, lai izpildītu noteiktu komandu. Metodes execute() sintakse ir norādīta tālāk.

Void execute (izpildāma komanda)

Apsveriet šādu piemēru:

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

Izvade

 Running Thread! Thread Completed 

36) Kas ir BlockingQueue?

Java.util.concurrent.BlockingQueue ir rindas apakšinterfeiss, kas atbalsta tādas darbības kā vietas pieejamības gaidīšana pirms jaunas vērtības ievietošanas vai gaidīšana, līdz rinda kļūs tukša, pirms tiek izgūts no tās elements. Apsveriet šādu piemēru.

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

Izvade

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

37) Kā īstenot ražotāja-patērētāja problēmu, izmantojot BlockingQueue?

Ražotāja-patērētāja problēmu var atrisināt, izmantojot BlockingQueue šādā veidā.

 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) Kāda ir atšķirība starp Java izsaucamo saskarni un Runnable interfeisu?

Gan izsaucamo saskarni, gan izpildāmo saskarni izmanto klases, kuras vēlējās izpildīt ar vairākiem pavedieniem. Tomēr starp abiem ir divas galvenās atšķirības:

• Izsaucamā saskarne var atgriezt rezultātu, savukārt izpildāmā saskarne nevar atgriezt rezultātu.
• Izsaucamā saskarne var izmest pārbaudītu izņēmumu, savukārt palaišanas saskarne nevar izmest pārbaudītu izņēmumu.
• Izsaucamo saskarni nevar izmantot pirms Java 5, turpretim var izmantot palaišanas saskarni.

39) Kas ir Atomic darbība vienlaicīgumā Java?

• Atomiskā darbība ir darbība, kuru var veikt vienā uzdevuma vienībā, netraucējot citām operācijām.
• Atomic darbību nevar apturēt starp uzdevumiem. Pēc palaišanas tā aizpildīšana apstājas tikai pēc uzdevuma pabeigšanas.
• Palielinājuma darbība, piemēram, a++, nepieļauj atomāru darbību.
• Visas primitīvā mainīgā lasīšanas un rakstīšanas darbības (izņemot garo un dubulto) ir atomu darbība.
• Visas mainīgā mainīgā lasīšanas un rakstīšanas darbības (tostarp garās un dubultās) ir atomu operācijas.
• Atomic metodes ir pieejamas java.util.Concurrent pakotnē.

40) Kas ir Java Concurrency API bloķēšanas interfeiss?

Kā sinhronizācijas mehānisms tiek izmantots interfeiss java.util.concurrent.locks.Lock. Tas darbojas līdzīgi sinhronizētajam blokam. Tālāk ir norādītas dažas atšķirības starp bloķēšanu un sinhronizēto bloku.

uri vs url

• Bloķēšanas interfeiss nodrošina secību, kurā gaidošajam pavedienam tiks piešķirta piekļuve, savukārt sinhronizētais bloks to negarantē.
• Bloķēšanas interfeiss nodrošina taimauta iespēju, ja bloķēšana netiek piešķirta, savukārt sinhronizētais bloks to nenodrošina.
• Bloķēšanas interfeisa metodes, t.i., Lock () un Unlock () var izsaukt dažādās metodēs, turpretim vienam sinhronizētam blokam ir jābūt pilnībā ietvertam vienā metodē.

41) Izskaidrojiet ExecutorService interfeisu.

ExecutorService interfeiss ir Executor interfeisa apakšinterfeiss un pievieno līdzekļus dzīves cikla pārvaldībai. Apsveriet šādu piemēru.

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

Izvade

 Shutdown executor shutdown finished 

42) Kāda ir atšķirība starp sinhrono programmēšanu un asinhrono programmēšanu attiecībā uz pavedienu?

Sinhronā programmēšana: Sinhronās programmēšanas modelī pavediens tiek piešķirts, lai pabeigtu uzdevumu, un līdz ar to pavediens sāka strādāt pie tā, un tas ir pieejams tikai citiem uzdevumiem, kad tiks pabeigts piešķirtais uzdevums.

Asinhronā programmēšana: Asinhronajā programmēšanā vienu darbu var pabeigt ar vairākiem pavedieniem, un tādējādi tas nodrošina maksimālu dažādu pavedienu lietojamību.

43) Ko jūs saprotat ar vārdiem Callable un Future Java?

Java izsaucams interfeiss: Java5 izsaucamo saskarni nodrošināja pakotne java.util.concurrent. Tas ir līdzīgs Runnable interfeisam, taču tas var atgriezt rezultātu un radīt izņēmumu. Tas nodrošina arī palaišanas () metodi pavediena izpildei. Java Callable var atgriezt jebkuru objektu, jo tas izmanto Generic.

Sintakse:

publiska saskarne Izsaucams

Java nākotnes saskarne: Java Future interfeiss nodrošina vienlaicīga procesa rezultātu. Izsaucamā saskarne atgriež objektu java.util.concurrent.Future.

Java Future nodrošina šādas ieviešanas metodes.

atcelt(būla�mayInterruptIfRunning):To izmanto, lai atceltu piešķirtā uzdevuma izpildi.gūt():Tas gaida laiku, ja izpilde nav pabeigta, un pēc tam izgūst rezultātu.ir Atcelts ():Tas atgriež Būla vērtību tāpat kā patiess, ja uzdevums tika atcelts pirms tā pabeigšanas.ir Gatavs ():Tas atgriež patiesu, ja darbs ir veiksmīgi pabeigts, pretējā gadījumā atgriež nepatiesu.

44. Kāda ir atšķirība starp ScheduledExecutorService un ExecutorService saskarni?

Gan ExecutorServcie, gan ScheduledExecutorService ir java.util.Concurrent pakotnes saskarnes, taču scheduledExecutorService nodrošina dažas papildu metodes, lai izpildītu izpildāmos un izsaucamos uzdevumus ar aizkavi vai katru fiksētu laika periodu.

45) Definēt FutureTask klasi Java?

Java FutureTask klase nodrošina Future interfeisa bāzes ieviešanu. Rezultātu var iegūt tikai tad, ja ir pabeigta viena uzdevuma izpilde, un, ja aprēķins nav sasniegts, tad get metode tiks bloķēta. Ja izpilde ir pabeigta, to nevar atsākt un to nevar atcelt.

Sintakse

publiskā klase FutureTask paplašina Objekts ievieš RunnableFuture