Monisäikeistystä ja synkronointia pidetään tyypillisinä Java-ohjelmoinnin lukuina. Pelikehitysyrityksissä kysytään enimmäkseen monisäikeisiin haastattelukysymyksiin liittyviä kysymyksiä. Alla on luettelo usein kysytyistä Java-monisäikeistä ja samanaikaisuushaastattelukysymyksistä.

Monisäikeiset haastattelukysymykset

1) Mitä on monisäikeisyys?

Monisäikeistys on prosessi, jossa suoritetaan useita säikeitä samanaikaisesti. Monisäikeistystä käytetään monitehtävän saavuttamiseen. Se kuluttaa vähemmän muistia ja tarjoaa nopean ja tehokkaan suorituskyvyn. Sen tärkeimmät edut ovat:

• Säikeet jakavat saman osoitetilan.
• Lanka on kevyttä.
• Prosessien välisen viestinnän kustannukset ovat alhaiset.

2) Mikä lanka on?

Lanka on kevyt osaprosessi. Se on erillinen suorituspolku, koska jokainen säie kulkee eri pinokehyksessä. Prosessi voi sisältää useita säikeitä. Säikeet jakavat prosessiresurssit, mutta silti ne suorittavat itsenäisesti.

3) Erotatko prosessin ja säikeen?

Prosessin ja säikeen välillä on seuraavat erot.

• Ohjelmaa suorituksessa kutsutaan prosessiksi, kun taas; Lanka on prosessin osajoukko
• Prosessit ovat itsenäisiä, kun taas säikeet ovat prosessin osajoukko.
• Prosessilla on eri osoitetila muistissa, kun taas säikeet sisältävät jaetun osoitetilan.
• Kontekstin vaihto on nopeampaa säikeiden välillä verrattuna prosesseihin.
• Prosessien välinen viestintä on hitaampaa ja kalliimpaa kuin säikeiden välinen viestintä.
• Mikään ylätason prosessin muutos ei vaikuta aliprosessiin, kun taas ylätason säikeen muutokset voivat vaikuttaa aliketjuun.

4) Mitä ymmärrät säikeiden välisellä viestinnällä?

• Synkronoitujen säikeiden välistä viestintää kutsutaan säikeiden väliseksi viestintäksi.
• Säikeiden välistä viestintää käytetään säikeiden pollauksen välttämiseksi Javassa.
• Säie keskeytetään sen kriittisessä osassa, ja toisen säikeen sallitaan tulla (tai lukkiutua) samaan kriittiseen osioon suoritettavaksi.
• Se voidaan saada odottamalla(), notify() ja notifyAll()-menetelmillä.

5) Mikä on wait()-menetelmän tarkoitus Javassa?

Waita()-menetelmän tarjoaa Object-luokka Javassa. Tätä menetelmää käytetään säikeiden väliseen viestintään Javassa. Java.lang.Object.wait()-komentoa käytetään keskeyttämään nykyinen säiettä ja odottamaan, kunnes toinen säie ei kutsu notify()- tai notifyAll()-metodia. Sen syntaksi on annettu alla.

julkinen lopullinen tyhjä odotus()

6) Miksi synkronoidusta lohkosta täytyy kutsua wait()-metodi?

Meidän täytyy kutsua odotusmenetelmää, muuten se heittää java.lang.IllegalMonitorStateException poikkeus. Lisäksi tarvitsemme wait()-menetelmän säikeiden väliseen kommunikaatioon notify()- ja notifyAll()-toimintojen kanssa. Siksi sen on oltava läsnä synkronoidussa lohkossa asianmukaista ja oikeaa viestintää varten.

7) Mitä etuja monisäikeisestä on?

Monisäikeisellä ohjelmoinnilla on seuraavat edut:

• Monisäikeistyksen avulla sovellus/ohjelma voi olla aina reaktiivinen syötettä varten, vaikka se olisi jo käynnissä joidenkin taustatehtävien kanssa
• Monisäikeistys mahdollistaa tehtävien nopeamman suorittamisen, koska säikeet suoritetaan itsenäisesti.
• Monisäikeistys tarjoaa paremman välimuistin käytön, koska säikeet jakavat yhteiset muistiresurssit.
• Monisäikeisyys vähentää tarvittavan palvelimen määrää, koska yksi palvelin voi suorittaa useita säikeitä kerrallaan.

8) Mitkä ovat säikeen elinkaaren tilat?

Säikeellä voi olla jokin seuraavista tiloista sen elinkaaren aikana:

Uusi:Tässä tilassa säieluokan objekti luodaan käyttämällä uutta operaattoria, mutta säie ei ole elossa. Säie ei ala ennen kuin kutsumme start()-metodia.Ajettavissa:Tässä tilassa säie on valmis ajoon start()-menetelmän kutsumisen jälkeen. Säikeen ajoitus ei kuitenkaan ole vielä valinnut säiettä.Juoksu:Tässä tilassa säikeen ajoitus poimii säikeen valmiustilasta ja säie on käynnissä.Odottaa/estetty:Tässä tilassa säie ei ole käynnissä, mutta se on edelleen elossa tai se odottaa toisen säikeen päättymistä.Kuollut / lopetettu:Säie on päättyneessä tai kuolleessa tilassa, kun run()-metodi suljetaan.

9) Mitä eroa on ennaltaehkäisevällä aikataululla ja aikaleikkauksella?

Ennakoivassa ajoituksessa korkeimman prioriteetin tehtävä suoritetaan, kunnes se siirtyy odottavaan tai kuolleeseen tilaan tai korkeamman prioriteetin tehtävä syntyy. Aikaleikkauksessa tehtävä suoritetaan ennalta määritetyn ajan ja palaa sitten valmiiden tehtävien joukkoon. Ajastin määrittää sitten, mikä tehtävä tulee suorittaa seuraavaksi prioriteetin ja muiden tekijöiden perusteella.

10) Mitä kontekstin vaihtaminen on?

Kontekstivaihdossa prosessin (tai säikeen) tila tallennetaan, jotta se voidaan palauttaa ja suoritusta voidaan jatkaa samasta kohdasta myöhemmin. Kontekstin vaihtaminen mahdollistaa sen, että useat prosessit voivat jakaa saman suorittimen.

11) Erottaako säieluokan ja ajettavan käyttöliittymän säiettä luotaessa?

Säie voidaan luoda kahdella tavalla.

• Laajentamalla Thread-luokkaa
• Toteuttamalla Runnable-käyttöliittymän

Kuitenkin tärkeimmät erot molempien tapojen välillä on esitetty alla:

• Laajentamalla Thread-luokkaa emme voi laajentaa mitään muuta luokkaa, koska Java ei salli useita perintöjä toteutettaessa Runnable-liitäntää; voimme myös laajentaa muuta perusluokkaa (tarvittaessa).
• Laajentamalla Thread-luokkaa kukin säikeistä luo ainutlaatuisen objektin ja liittää sen toteuttaessaan Runnable-liittymää; useat säikeet jakavat saman objektin
• Thread-luokka tarjoaa erilaisia ​​sisäänrakennettuja menetelmiä, kuten getPriority(), isAlive ja monia muita, kun taas Runnable-liittymä tarjoaa yhden menetelmän, eli run().

12) Mitä join()-metodi tarkoittaa?

Join()-metodi odottaa säikeen kuolemista. Toisin sanoen se saa käynnissä olevat säikeet lopettamaan suorittamisen, kunnes säie, johon se liittyy, suorittaa tehtävänsä. Join-menetelmä on ylikuormitettu Thread-luokassa seuraavilla tavoilla.

• public void join()heittää InterruptedException
• public void join(pitkä millisekunti)heittää InterruptedException

13) Kuvaile sleep()-menetelmän tarkoitusta ja toimintaa.

Sleep()-menetelmää Javassa käytetään estämään säiettä tietyksi ajaksi, mikä tarkoittaa, että se keskeyttää säikeen suorittamisen tietyksi ajaksi. On olemassa kaksi tapaa tehdä se.

Syntaksi:

jotain nopeaa lajittelua

• julkinen staattinen void uni (pitkät millisekuntit)heitot InterruptedException
• julkinen staattinen void-lepotila (pitkät millisekuntit, int nanot)heittoja InterruptedException

Sleep()-menetelmän käyttö

vaihda väri gimpissä

Kun kutsumme sleep()-menetelmää, se keskeyttää nykyisen säikeen suorituksen tietyksi ajaksi ja antaa etusijalle toiselle säikeelle (jos saatavilla). Lisäksi kun odotusaika on päättynyt, edellinen säie muuttaa tilan odottamisesta suoritettavaksi ja tulee käynnissä olevaan tilaan, ja koko prosessi toimii niin edelleen, kunnes suoritus ei ole valmis.

14) Mitä eroa on wait()- ja sleep()-metodilla?

15) Onko mahdollista aloittaa säiettä kahdesti?

Ei, emme voi käynnistää säiettä uudelleen, sillä kun säiettä on aloitettu ja suoritettu, se siirtyy kuolleeseen tilaan. Siksi, jos yritämme aloittaa säiettä kahdesti, se antaa runtimeExceptionin 'java.lang.IllegalThreadStateException'. Harkitse seuraavaa esimerkkiä.

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

Lähtö

 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) Voimmeko kutsua run()-metodia start():n sijaan?

Kyllä, run()-menetelmän kutsuminen suoraan on kelvollinen, mutta se ei toimi säikeenä, vaan toimii normaalina objektina. Säikeiden välillä ei tapahdu kontekstin vaihtoa. Kun kutsumme start()-metodia, se kutsuu sisäisesti run()-menetelmää, joka luo säikeelle uuden pinon, kun taas run()-menetelmän kutsuminen suoraan ei luo uutta pinoa.

17) Entä demon-säikeet?

Daemon-säikeet ovat matalan prioriteetin säikeitä, jotka tarjoavat taustatuen ja -palvelut käyttäjäsäikeille. JVM lopettaa daemon-säikeen automaattisesti, jos ohjelma pysyy vain demonsäikeessä ja kaikki muut käyttäjäsäikeet lopetetaan/kuollaan. Thread-luokassa on saatavilla kaksi menetelmää daemon-säikeille:

public void setDaemon(boolen tila):Sitä käytettiin merkitsemään säikeen demon-säie tai käyttäjäsäie.julkinen boolean isDaemon():Se tarkistaa, onko säiettä demoni vai ei.

18) Voimmeko tehdä käyttäjäsäikeestä daemon-säikeen, jos säiettä käynnistetään?

Ei, jos teet niin, se heittää IllegalThreadStateExceptionin. Siksi voimme luoda vain demon-säikeen ennen säikeen aloittamista.

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

Lähtö

 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) Mikä on sammutuskoukku?

Sammutuskoukku on lanka, jota kutsutaan implisiittisesti ennen kuin JVM sammuu. Joten voimme käyttää sitä resurssin puhdistamiseen tai tilan tallentamiseen, kun JVM sammuu normaalisti tai äkillisesti. Voimme lisätä sammutuskoukun seuraavalla menetelmällä:

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

Joitakin tärkeitä sammutuskoukkuja koskevia kohtia ovat:

• Sammutuskoukut alustettiin, mutta ne voidaan käynnistää vain, kun JVM:n sammutus tapahtui.
• Sammutuskoukut ovat luotettavampia kuin finalizer(), koska on hyvin vähemmän mahdollisuuksia, että sammutuskoukut eivät toimi.
• Sammutuskoukku voidaan pysäyttää kutsumalla Runtime-luokan halt(int)-metodia.

20) Milloin meidän pitäisi keskeyttää ketju?

Meidän tulee keskeyttää säiettä, kun haluamme katkaista säikeen lepotilan tai odotustilan. Voimme keskeyttää säikeen kutsumalla interrupt()-funktiota heittämällä InterruptedExceptionin.

21) Mikä on synkronointi?

Synkronointi on kyky hallita useiden säikeiden pääsyä mihin tahansa jaettuun resurssiin. Sitä käytetään:

1. Langan häiriöiden estämiseksi.
2. Estä johdonmukaisuusongelmat.

Kun useat säikeet yrittävät suorittaa saman tehtävän, on mahdollista, että tulos on virheellinen, joten tämän ongelman poistamiseksi Java käyttää synkronointiprosessia, joka sallii vain yhden säikeen suorittamisen kerrallaan. Synkronointi voidaan saavuttaa kolmella tavalla:

• synkronoidulla menetelmällä
• synkronoidulla lohkolla
• staattisen synkronoinnin avulla

Synkronoidun lohkon syntaksi

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

22) Mikä on Synkronoidun lohkon tarkoitus?

Synkronoitua lohkoa voidaan käyttää synkronoinnin suorittamiseen menetelmän mille tahansa tietylle resurssille. Vain yksi säie kerrallaan voi suorittaa tietyssä resurssissa, ja kaikki muut säikeet, jotka yrittävät päästä synkronoituun lohkoon, estetään.

• Synkronoitua lohkoa käytetään objektin lukitsemiseen mille tahansa jaetulle resurssille.
• Synkronoidun lohkon laajuus on rajoitettu lohkoon, johon sitä sovelletaan. Sen laajuus on pienempi kuin menetelmä.

23) Voidaanko Java-objekti lukita tietyn säikeen yksinomaiseen käyttöön?

Joo. Voit lukita kohteen asettamalla sen 'synkronoituun' lohkoon. Lukittu objekti ei ole käytettävissä millään muulla säikeellä kuin se, joka nimenomaisesti vaati sitä.

24) Mikä on staattinen synkronointi?

Jos teet minkä tahansa staattisen menetelmän synkronoitavaksi, lukko on luokassa, ei objektissa. Jos käytämme synkronoitua avainsanaa ennen menetelmää, niin se lukitsee objektin (yksi säiettä voi käyttää objektia kerrallaan), mutta jos käytämme staattista synkronointia, se lukitsee luokan (yksi säiettä voi käyttää luokkaa kerrallaan). Lisätietoja.

25) Mitä eroa notify() ja notifyAll() on?

Notify()-toimintoa käytetään yhden odottavan säikeen eston poistamiseen, kun taas notifyAll()-menetelmää käytetään kaikkien odotustilassa olevien säikeiden eston poistamiseen.

26) Mikä on umpikuja?

Umpikuja on tilanne, jossa jokainen säiettä odottaa resurssia, jota joku toinen odottava säie pitää. Tässä tilanteessa kumpikaan säiettä ei suorita eikä se saa mahdollisuutta suorittaa. Sen sijaan kaikkien säikeiden joukossa on yleinen odotustila. Lukitus on erittäin monimutkainen tilanne, joka voi rikkoa koodimme ajon aikana.

27) Miten umpikujatilanne havaitaan? Miten se voidaan välttää?

Voimme havaita lukkiutumisen suorittamalla koodin cmd:ssä ja keräämällä säikeen vedos, ja jos koodissa on lukkiutumista, cmd:ssä näkyy viesti.

Tapoja välttää lukkiutumistila Javassa:

Vältä sisäkkäistä lukkoa:Sisäkkäinen lukko on yleinen syy umpikujaan, koska lukkiutumista tapahtuu, kun tarjoamme lukkoja useille säikeille, joten meidän tulisi antaa yksi lukko vain yhdelle säikeelle tiettynä aikana.Vältä tarpeettomia lukkoja:meidän on vältettävä lukkoja, joita ei vaadita.Ketjuliitoksen käyttäminen:Säikeen yhdistäminen auttaa odottamaan säiettä, kunnes toinen säie ei lopeta sen suorittamista, jotta voimme välttää lukkiutumisen käyttämällä liitosmenetelmää mahdollisimman paljon.

28) Mikä on Thread Scheduler javassa?

Javalla, kun luomme säikeitä, niitä valvotaan JVM:n osana olevan Thread Schedulerin avulla. Säikeen ajoitus on vain vastuussa suoritettavan säikeen päättämisestä. Säikeen ajoitus käyttää kahta mekanismia säikeiden ajoittamiseen: ennaltaehkäisevää ja aikaleikkausta.

• Se valitsee ketjun prioriteetin.
• Se määrittää langan odotusajan
• Se tarkistaa langan luonteen

29) Onko jokaisella säikeellä pinonsa monisäikeisessä ohjelmoinnissa?

Kyllä, monisäikeisessä ohjelmoinnissa jokainen säie säilyttää oman tai erillisen pinoalueensa muistissa, minkä ansiosta jokainen säie on riippumaton toisistaan.

30) Miten langan turvallisuus saavutetaan?

Jos menetelmää tai luokkaobjektia voivat käyttää useat säikeet kerralla ilman kilpailuehtoja, luokka on säikeen turvallinen. Säikeen turvaa käytetään tekemään ohjelmasta turvallinen käyttää monisäikeisessä ohjelmoinnissa. Se voidaan saavuttaa seuraavilla tavoilla:

• Synkronointi
• Haihtuvan avainsanan käyttö
• Lukkoon perustuvan mekanismin käyttö
• Atomikääreluokkien käyttö

31) Mikä on rotuehto?

Kilpaehto on ongelma, joka ilmenee monisäikeisessä ohjelmoinnissa, kun useat säikeet suorittavat samanaikaisesti pääsyn jaettuun resurssiin samaan aikaan. Synkronoinnin oikea käyttö voi välttää kilpailutilanteen.

32) Mikä on haihtuva avainsana javassa?

Haihtuvaa avainsanaa käytetään monisäikeisessä ohjelmoinnissa säikeen turvallisuuden saavuttamiseksi, koska muutos yhdessä haihtuvassa muuttujassa näkyy kaikille muille säikeille, joten yksi säie voi käyttää yhtä muuttujaa kerrallaan.

33) Mitä ymmärrät säikeellä?

• Java-säievarasto edustaa ryhmää työsäikeitä, jotka odottavat tehtävän varaamista.
• Säikeen säikeitä valvoo palveluntarjoaja, joka vetää yhden säikeen ryhmästä ja määrittää sille työn.
• Annetun tehtävän suorittamisen jälkeen lanka tuli taas lankavarastoon.
• Säikevaraston koko riippuu suoritettavaksi varattujen säikeiden kokonaismäärästä.

Lanka-altaan edut ovat:

• Säiepoolia käyttämällä voidaan parantaa suorituskykyä.
• Säiepoolia käyttämällä voidaan saavuttaa parempaa järjestelmän vakautta.

Samanaikaisuushaastattelukysymykset

34) Mitkä ovat concurrency API:n pääkomponentit?

Concurrency API voidaan kehittää käyttämällä java.util.Concurrent-paketin luokkaa ja rajapintoja. Java.util.Concurrent-paketissa on seuraavat luokat ja käyttöliittymät.

• Toteuttaja
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Tulevaisuus
• Aikayksikkö (Enum)
• CountdownLatch
• CyclicBarrier
• Semafori
• ThreadFactory
• BlockingQueue
• DelayQueue
• Lukot
• Phaser

35) Mikä on Javan Concurrency API:n Executor-liittymä?

Paketin java.util.concurrent tarjoama Executor Interface on yksinkertainen käyttöliittymä, jota käytetään uuden tehtävän suorittamiseen. Executor-rajapinnan execute()-menetelmää käytetään tietyn komennon suorittamiseen. execute()-menetelmän syntaksi on annettu alla.

void execute (suoritettava komento)

Harkitse seuraavaa esimerkkiä:

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

Lähtö

java silmukat

 Running Thread! Thread Completed 

36) Mikä on BlockingQueue?

java.util.concurrent.BlockingQueue on Queuen aliliittymä, joka tukee toimintoja, kuten odottamista tilan saatavuudesta ennen uuden arvon lisäämistä tai odottamista, että jonosta tulee ei-tyhjä, ennen kuin se noutaa elementin siitä. Harkitse seuraavaa esimerkkiä.

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

Lähtö

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

37) Kuinka toteuttaa tuottaja-kuluttaja -ongelma käyttämällä BlockingQueuea?

Tuottaja-kuluttaja -ongelma voidaan ratkaista käyttämällä BlockingQueuea seuraavalla tavalla.

 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) Mitä eroa on Java Callable -liittymällä ja ajettavalla käyttöliittymällä?

Kutsuttavaa käyttöliittymää ja suoritettavaa käyttöliittymää käyttävät luokat, jotka halusivat suorittaa useilla säikeillä. Näiden kahden välillä on kuitenkin kaksi tärkeintä eroa:

• Kutsuttava käyttöliittymä voi palauttaa tuloksen, kun taas suoritettava käyttöliittymä ei voi palauttaa tulosta.
• Kutsuttava käyttöliittymä voi heittää tarkistetun poikkeuksen, kun taas suoritettava käyttöliittymä ei voi heittää tarkistettua poikkeusta.
• Kutsuttavaa käyttöliittymää ei voi käyttää ennen Java 5:tä, kun taas suoritettavaa käyttöliittymää voidaan käyttää.

39) Mikä on Atomic-toiminto Javan Concurrency-ohjelmassa?

• Atomitoiminto on operaatio, joka voidaan suorittaa yhdessä tehtävän yksikössä ilman muiden toimintojen häiriöitä.
• Atomic-toimintoa ei voi pysäyttää tehtävän välissä. Kun se on aloitettu, täyttö pysähtyy vasta tehtävän suorittamisen jälkeen.
• Kasvausoperaatio, kuten a++, ei salli atomitoimintaa.
• Kaikki primitiivisen muuttujan luku- ja kirjoitusoperaatiot (paitsi pitkä ja tupla) ovat atomioperaatioita.
• Kaikki haihtuvan muuttujan luku- ja kirjoitusoperaatiot (mukaan lukien pitkä ja kaksinkertainen) ovat atomitoimintoja.
• Atomic-menetelmät ovat saatavilla java.util.Concurrent-paketissa.

40) Mikä on lukkorajapinta Concurrency API:ssa Javassa?

Synkronointimekanismina käytetään java.util.concurrent.locks.Lock-liitäntää. Se toimii samalla tavalla kuin synkronoitu lohko. Lukon ja synkronoidun lohkon välillä on muutamia eroja, jotka on esitetty alla.

• Lukitusrajapinta takaa sen järjestyksen, jossa odottavalle säikeelle annetaan pääsy, kun taas synkronoitu lohko ei takaa sitä.
• Lukitusrajapinta tarjoaa mahdollisuuden aikakatkaisuun, jos lukkoa ei myönnetä, kun taas synkronoitu lohko ei tarjoa sitä.
• Lukitusrajapinnan menetelmiä, eli Lock() ja Unlock() voidaan kutsua eri menetelmillä, kun taas yksi synkronoitu lohko on sisällytettävä kokonaan yhteen menetelmään.

41) Selitä ExecutorService-liitäntä.

ExecutorService Interface on Executor-käyttöliittymän alirajapinta ja se lisää ominaisuuksia elinkaaren hallintaan. Harkitse seuraavaa esimerkkiä.

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

Lähtö

 Shutdown executor shutdown finished 

42) Mitä eroa on synkronisella ohjelmoinnilla ja asynkronisella ohjelmoinnilla säikeen suhteen?

Synkroninen ohjelmointi: Synkronisessa ohjelmointimallissa säie on määritetty suorittamaan tehtävä, ja säie aloitti työskentelyn siinä, ja se on käytettävissä vain muihin tehtäviin, kun se lopettaa määritetyn tehtävän.

Asynkroninen ohjelmointi: Asynkronisessa ohjelmoinnissa yksi työ voidaan suorittaa useilla säikeillä ja siten se tarjoaa eri säikeiden maksimaalisen käytettävyyden.

43) Mitä ymmärrät Callable- ja Future-sanomilla Javassa?

Java-soitava käyttöliittymä: Java5:ssä kutsuttavan käyttöliittymän tarjosi paketti java.util.concurrent. Se on samanlainen kuin Runnable-käyttöliittymä, mutta se voi palauttaa tuloksen ja antaa poikkeuksen. Se tarjoaa myös run()-menetelmän säikeen suorittamiseen. Java Callable voi palauttaa minkä tahansa objektin, koska se käyttää Genericä.

Syntaksi:

julkinen käyttöliittymä Soitettava

Estä mainokset YouTubessa Android

Java Future -käyttöliittymä: Java Future -käyttöliittymä antaa samanaikaisen prosessin tuloksen. Kutsuttava käyttöliittymä palauttaa objektin java.util.concurrent.Future.

Java Future tarjoaa seuraavat toteutustavat.

peruuta(boolean�voiInterruptIfRunning):Sitä käytetään määrätyn tehtävän suorittamisen peruuttamiseen.saada():Se odottaa aikaa, jos suoritusta ei ole suoritettu loppuun, ja noutaa sitten tuloksen.isCanceled():Se palauttaa Boolen arvon, koska se palauttaa tosi, jos tehtävä peruutettiin ennen sen valmistumista.on tehty():Palauttaa tosi, jos työ on suoritettu onnistuneesti, muuten palauttaa epätosi.

44. Mitä eroa on ScheduledExecutorService- ja ExecutorService-liittymän välillä?

ExecutorServcie ja ScheduledExecutorService ovat molemmat java.util.Concurrent-paketin rajapintoja, mutta scheduledExecutorService tarjoaa joitain lisämenetelmiä Runnable- ja Callable-tehtävien suorittamiseen viiveellä tai joka kiinteä aika.

45) Määritä FutureTask-luokka Javassa?

Java FutureTask -luokka tarjoaa Future-käyttöliittymän perustoteutuksen. Tulos voidaan saada vain, jos yksi tehtävä on suoritettu loppuun, ja jos laskentaa ei saavuteta, get-menetelmä estetään. Jos suoritus on valmis, sitä ei voi aloittaa uudelleen eikä peruuttaa.

Syntaksi

julkinen luokka FutureTask laajentaa Object toteuttaa RunnableFuture