Multithreading og synkronisering regnes som det typiske kapittelet i java-programmering. I spillutviklingsselskaper stilles det meste av multithreading-relaterte intervjuspørsmål. En liste over ofte stilte spørsmål om java multithreading og samtidighetsintervjuer er gitt nedenfor.

Multithreading intervjuspørsmål

1) Hva er multithreading?

Multithreading er en prosess med å kjøre flere tråder samtidig. Multithreading brukes for å oppnå multitasking. Den bruker mindre minne og gir rask og effektiv ytelse. Dens viktigste fordeler er:

• Tråder deler samme adresseområde.
• Tråden er lett.
• Kostnaden for kommunikasjon mellom prosessene er lav.

2) Hva er tråden?

En tråd er en lett underprosess. Det er en egen bane for utførelse fordi hver tråd løper i en annen stabelramme. En prosess kan inneholde flere tråder. Tråder deler prosessressursene, men de utføres likevel uavhengig.

3) Skille mellom prosess og tråd?

Det er følgende forskjeller mellom prosessen og tråden.

• Et program i utførelsen kalles prosessen mens; En tråd er en delmengde av prosessen
• Prosesser er uavhengige, mens tråder er undergruppen av prosessen.
• Prosessen har forskjellig adresserom i minnet, mens tråder inneholder et delt adresseområde.
• Kontekstbytte er raskere mellom trådene sammenlignet med prosesser.
• Kommunikasjon mellom prosesser er tregere og kostbar enn kommunikasjon mellom tråder.
• Enhver endring i den overordnede prosessen påvirker ikke den underordnede prosessen, mens endringer i den overordnede tråden kan påvirke den underordnede tråden.

4) Hva forstår du med kommunikasjon mellom tråder?

• Prosessen med kommunikasjon mellom synkroniserte tråder kalles kommunikasjon mellom tråder.
• Kommunikasjon mellom tråder brukes for å unngå trådpolling i Java.
• Tråden settes på pause i den kritiske delen, og en annen tråd tillates å gå inn (eller låse) i den samme kritiske delen som skal kjøres.
• Den kan fås ved hjelp av wait(), notify() og notifyAll() metoder.

5) Hva er hensikten med wait()-metoden i Java?

wait()-metoden leveres av Object-klassen i Java. Denne metoden brukes for inter-thread kommunikasjon i Java. Java.lang.Object.wait() brukes til å sette den gjeldende tråden på pause, og vente til en annen tråd ikke kaller notify()- eller notifyAll()-metoden. Syntaksen er gitt nedenfor.

offentlig endelig ugyldig vent()

6) Hvorfor må wait()-metoden kalles fra den synkroniserte blokken?

Vi må kalle ventemetoden ellers vil det kaste java.lang.IllegalMonitorStateException unntak. Dessuten trenger vi wait()-metoden for inter-thread-kommunikasjon med notify() og notifyAll(). Derfor må den være til stede i den synkroniserte blokken for riktig og korrekt kommunikasjon.

7) Hva er fordelene med multithreading?

Multithreading-programmering har følgende fordeler:

• Multithreading lar en applikasjon/program alltid være reaktiv for input, selv kjører allerede med noen bakgrunnsoppgaver
• Multithreading tillater raskere utførelse av oppgaver, ettersom tråder kjøres uavhengig.
• Multithreading gir bedre utnyttelse av cache-minne ettersom tråder deler de vanlige minneressursene.
• Multithreading reduserer antallet påkrevde servere ettersom en server kan kjøre flere tråder om gangen.

8) Hva er tilstandene i livssyklusen til en tråd?

En tråd kan ha en av følgende tilstander i løpet av levetiden:

Ny:I denne tilstanden opprettes et Thread-klasseobjekt ved hjelp av en ny operator, men tråden er ikke i live. Tråden starter ikke før vi kaller start()-metoden.Kjørbar:I denne tilstanden er tråden klar til å kjøre etter å ha kalt start()-metoden. Tråden er imidlertid ennå ikke valgt av trådplanleggeren.Løping:I denne tilstanden velger trådplanleggeren tråden fra klar-tilstanden, og tråden kjører.Venter/blokkert:I denne tilstanden kjører ikke en tråd, men den er fortsatt i live, eller den venter på at den andre tråden skal fullføres.Død/avsluttet:En tråd er i avsluttet eller død tilstand når run()-metoden avsluttes.

9) Hva er forskjellen mellom forebyggende planlegging og tidsskjæring?

Under forebyggende planlegging utføres oppgaven med høyest prioritet til den går inn i vente- eller dødtilstanden eller en oppgave med høyere prioritet kommer til. Under tidsavsnitt utføres en oppgave i en forhåndsdefinert tidsperiode og går deretter inn i utvalget av klare oppgaver på nytt. Planleggeren bestemmer deretter hvilken oppgave som skal utføres neste gang, basert på prioritet og andre faktorer.

10) Hva er kontekstbytte?

I kontekstbytte lagres tilstanden til prosessen (eller tråden) slik at den kan gjenopprettes og utførelsen kan gjenopptas fra samme punkt senere. Kontekstbytte gjør det mulig for flere prosesser å dele samme CPU.

11) Skille mellom Thread-klassen og Runnable-grensesnittet for å lage en Thread?

Tråden kan opprettes på to måter.

• Ved å utvide trådklassen
• Ved å implementere Runnable-grensesnittet

Imidlertid er de primære forskjellene mellom begge måtene gitt nedenfor:

• Ved å utvide Thread-klassen kan vi ikke utvide noen annen klasse, da Java ikke tillater flere arv mens vi implementerer Runnable-grensesnittet; vi kan også utvide annen basisklasse (hvis nødvendig).
• Ved å utvide Thread-klassen, skaper hver tråd det unike objektet og assosieres med det mens de implementerer Runnable-grensesnittet; flere tråder deler samme objekt
• Trådklassen gir forskjellige innebygde metoder som getPriority(), isAlive og mange flere, mens Runnable-grensesnittet gir en enkelt metode, dvs. run().

12) Hva betyr join()-metoden?

join()-metoden venter på at en tråd dør. Med andre ord fører det til at trådene som kjører for øyeblikket slutter å kjøre til tråden den kobles til fullfører oppgaven. Join-metoden er overbelastet i Thread-klassen på følgende måter.

• public void join() kaster InterruptedException
• public void join(lange millisekunder) kaster InterruptedException

13) Beskriv formålet med og virkemåten til sleep() metoden.

Sleep()-metoden i java brukes til å blokkere en tråd for en bestemt tid, noe som betyr at den pauser utførelsen av en tråd for en bestemt tid. Det er to måter å gjøre det på.

Syntaks:

lengde på streng java

• offentlig statisk tomrom søvn (lange millisekunder) kaster InterruptedException
• offentlig statisk tomrom søvn (lange millisekunder, int nanos) kaster avbrutt unntak

Arbeid av sleep()-metoden

Når vi kaller sleep()-metoden, pauser den utførelsen av den gjeldende tråden for den gitte tiden og gir prioritet til en annen tråd (hvis tilgjengelig). Dessuten, når ventetiden er fullført, endrer forrige tråd sin tilstand fra å vente til å kjøre og kommer i kjørende tilstand, og hele prosessen fungerer slik til utførelsen ikke fullføres.

14) Hva er forskjellen mellom wait() og sleep() metoden?

15) Er det mulig å starte en tråd to ganger?

Nei, vi kan ikke starte tråden på nytt, ettersom en tråd først er startet og utført, går den til Død tilstand. Derfor, hvis vi prøver å starte en tråd to ganger, vil den gi en runtimeException 'java.lang.IllegalThreadStateException'. Tenk på følgende eksempel.

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

Produksjon

 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) Kan vi kalle run()-metoden i stedet for start()?

Ja, å kalle run()-metoden direkte er gyldig, men den vil ikke fungere som en tråd i stedet, den vil fungere som et normalt objekt. Det vil ikke være kontekstbytte mellom trådene. Når vi kaller start()-metoden, kaller den internt run()-metoden, som oppretter en ny stabel for en tråd, mens direkte anrop av run() ikke vil lage en ny stabel.

eksempel binært søketre

17) Hva med daemon-trådene?

Daemon-trådene er de lavprioriterte trådene som gir bakgrunnsstøtte og tjenester til brukertrådene. Daemon-tråden blir automatisk avsluttet av JVM hvis programmet bare forblir med daemon-tråden, og alle andre brukertråder avsluttes/døde. Det er to metoder for daemon-tråd tilgjengelig i Thread-klassen:

public void setDaemon(boolsk status):Den pleide å merke tråddemon-tråden eller en brukertråd.offentlig boolsk isDaemon():Den sjekker at tråden er demon eller ikke.

18)Kan vi lage brukertråden som daemon-tråd hvis tråden startes?

Nei, hvis du gjør det, vil det kaste IllegalThreadStateException. Derfor kan vi bare lage en daemon-tråd før vi starter tråden.

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

Produksjon

 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) Hva er shutdown krok?

Avstengningskroken er en tråd som påkalles implisitt før JVM slår seg av. Så vi kan bruke den til å rydde opp i ressursen eller lagre tilstanden når JVM slår seg av normalt eller brått. Vi kan legge til avslutningskrok ved å bruke følgende metode:

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

Noen viktige punkter om avstengningskroker er:

• Avslutningskroker initialisert, men kan bare startes når JVM-avstengning skjedde.
• Shutdown-kroker er mer pålitelige enn finalizer() fordi det er svært færre sjanser for at shutdown-kroker ikke kjører.
• Avslutningskroken kan stoppes ved å kalle halt(int)-metoden til Runtime-klassen.

20) Når bør vi avbryte en tråd?

Vi bør avbryte en tråd når vi ønsker å bryte ut søvn- eller ventetilstanden til en tråd. Vi kan avbryte en tråd ved å kalle interrupt()�throwing InterruptedException.

21) Hva er synkroniseringen?

Synkronisering er muligheten til å kontrollere tilgangen til flere tråder til en hvilken som helst delt ressurs. Det er brukt:

1. For å forhindre trådinterferens.
2. For å forhindre konsistensproblem.

Når flere tråder prøver å gjøre den samme oppgaven, er det en mulighet for et feilaktig resultat, og for å fjerne dette problemet bruker Java synkroniseringsprosessen som lar bare én tråd kjøres om gangen. Synkronisering kan oppnås på tre måter:

• ved den synkroniserte metoden
• ved synkronisert blokk
• ved statisk synkronisering

Syntaks for synkronisert blokk

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

22) Hva er formålet med den synkroniserte blokken?

Den synkroniserte blokken kan brukes til å utføre synkronisering på en hvilken som helst spesifikk ressurs i metoden. Bare én tråd om gangen kan kjøres på en bestemt ressurs, og alle andre tråder som forsøker å gå inn i den synkroniserte blokken blir blokkert.

• Synkronisert blokk brukes til å låse et objekt for enhver delt ressurs.
• Omfanget av den synkroniserte blokken er begrenset til blokken som den brukes på. Omfanget er mindre enn en metode.

23)Kan Java-objekt låses for eksklusiv bruk av en gitt tråd?

Ja. Du kan låse et objekt ved å sette det i en 'synkronisert' blokk. Det låste objektet er utilgjengelig for noen annen tråd enn den som eksplisitt gjorde krav på det.

24) Hva er statisk synkronisering?

Hvis du lager en statisk metode som synkronisert, vil låsen være på klassen og ikke på objektet. Hvis vi bruker det synkroniserte nøkkelordet før en metode så vil det låse objektet (en tråd kan få tilgang til et objekt om gangen), men hvis vi bruker statisk synkronisert så vil det låse en klasse (en tråd kan få tilgang til en klasse om gangen). Mer informasjon.

25) Hva er forskjellen mellom notify() og notifyAll()?

Notify() brukes til å oppheve blokkeringen av én ventende tråd, mens notifyAll()-metoden brukes til å oppheve blokkeringen av alle trådene i ventetilstand.

26) Hva er vranglåsen?

Deadlock er en situasjon der hver tråd venter på en ressurs som holdes av en annen ventende tråd. I denne situasjonen kjører ingen av tråden eller får sjansen til å bli utført. I stedet eksisterer det en universell ventetilstand blant alle trådene. Deadlock er en veldig komplisert situasjon som kan bryte koden vår under kjøring.

27) Hvordan oppdage en fastlåst tilstand? Hvordan kan det unngås?

Vi kan oppdage dødlåstilstanden ved å kjøre koden på cmd og samle tråddumpen, og hvis det er noen dødlås i koden, vil en melding vises på cmd.

Måter å unngå dødlåstilstanden i Java:

Unngå nestet lås:Nestet lås er den vanlige årsaken til vranglås da vranglås oppstår når vi gir låser til forskjellige tråder, så vi bør gi én lås til bare én tråd på et bestemt tidspunkt.Unngå unødvendige låser:vi må unngå låsene som ikke er påkrevd.Bruke trådsammenføyning:Trådsammenføyning hjelper å vente på en tråd til en annen tråd ikke fullfører utføringen, slik at vi kan unngå dødlås ved maksimal bruk av sammenføyningsmetoden.

28) Hva er Thread Scheduler i java?

I Java, når vi lager trådene, blir de overvåket ved hjelp av en trådplanlegger, som er en del av JVM. Trådplanlegger er kun ansvarlig for å bestemme hvilken tråd som skal kjøres. Trådplanlegger bruker to mekanismer for å planlegge trådene: Preemptive og Time Slicing.

• Den velger prioritet til tråden.
• Det bestemmer ventetiden for en tråd
• Den sjekker trådens natur

29) Har hver tråd sin stabel i flertrådsprogrammering?

Ja, i flertrådsprogrammering opprettholder hver tråd sitt eget eller separate stabelområde i minnet på grunn av at hver tråd er uavhengig av hverandre.

30) Hvordan oppnås sikkerheten til en tråd?

Hvis en metode eller klasseobjekt kan brukes av flere tråder om gangen uten noen rasebetingelse, er klassen trådsikker. Trådsikkerhet brukes for å gjøre et program trygt å bruke i flertrådsprogrammering. Det kan oppnås på følgende måter:

• Synkronisering
• Bruker flyktig nøkkelord
• Ved hjelp av en låsbasert mekanisme
• Bruk av atominnpakningsklasser

31) Hva er rasetilstand?

En Race-tilstand er et problem som oppstår i flertrådsprogrammering når forskjellige tråder kjøres samtidig og får tilgang til en delt ressurs på samme tid. Riktig bruk av synkronisering kan unngå Race-tilstanden.

32) Hva er det flyktige søkeordet i java?

Volatile nøkkelord brukes i flertrådsprogrammering for å oppnå trådsikkerheten, ettersom en endring i én flyktig variabel er synlig for alle andre tråder, slik at én variabel kan brukes av én tråd om gangen.

33) Hva forstår du med trådpool?

• Java Thread pool representerer en gruppe arbeidertråder som venter på at oppgaven skal tildeles.
• Tråder i trådbasen overvåkes av tjenesteleverandøren som trekker en tråd fra bassenget og tildeler den en jobb.
• Etter fullføring av den gitte oppgaven kom tråden igjen til trådbassenget.
• Størrelsen på trådpoolen avhenger av det totale antallet tråder som er reservert for utførelse.

Fordelene med trådbassenget er:

• Ved å bruke en trådpool kan ytelsen forbedres.
• Ved å bruke et trådbasseng kan det oppstå bedre systemstabilitet.

Spørsmål om samtidig intervju

34) Hva er hovedkomponentene i concurrency API?

Concurrency API kan utvikles ved å bruke klassen og grensesnittene til java.util.Concurrent-pakken. Det er følgende klasser og grensesnitt i java.util.Concurrent-pakken.

• Utfører
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Framtid
• Tidsenhet (Enum)
• CountDownLatch
• CyclicBarrier
• Semafor
• ThreadFactory
• Blokkeringskø
• DelayQueue
• Låser
• Phaser

35) Hva er Executor-grensesnittet i Concurrency API i Java?

Executor Interface levert av pakken java.util.concurrent er det enkle grensesnittet som brukes til å utføre den nye oppgaven. execute()-metoden til Executor-grensesnittet brukes til å utføre en gitt kommando. Syntaksen til execute()-metoden er gitt nedenfor.

void execute (kjørbar kommando)

java switch uttalelse

Tenk på følgende eksempel:

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

Produksjon

 Running Thread! Thread Completed 

36) Hva er BlockingQueue?

java.util.concurrent.BlockingQueue er undergrensesnittet til Queue som støtter operasjoner som å vente på plasstilgjengeligheten før du setter inn en ny verdi eller å vente på at køen ikke blir tom før du henter et element fra den. Tenk på følgende eksempel.

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

Produksjon

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

37) Hvordan implementere produsent-forbrukerproblem ved å bruke BlockingQueue?

Produsent-forbrukerproblemet kan løses ved å bruke BlockingQueue på følgende måte.

 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) Hva er forskjellen mellom Java Callable-grensesnitt og Runnable-grensesnitt?

Callable-grensesnittet og Runnable-grensesnittet brukes begge av klassene som ønsket å kjøre med flere tråder. Imidlertid er det to hovedforskjeller mellom begge:

• Et Callable-grensesnitt kan returnere et resultat, mens Runnable-grensesnittet ikke kan returnere noe resultat.
• Et Callable-grensesnitt kan gi et sjekket unntak, mens det Runnable-grensesnittet ikke kan gi et sjekket unntak.
• Et Callable-grensesnitt kan ikke brukes før Java 5, mens Runnable-grensesnittet kan brukes.

39) Hva er atomhandlingen i samtidighet i Java?

• Atomhandlingen er operasjonen som kan utføres i en enkelt enhet av en oppgave uten forstyrrelse av de andre operasjonene.
• Atomic-handlingen kan ikke stoppes mellom oppgavene. Når den er startet, stopper den bare etter fullføring av oppgaven.
• En inkrementoperasjon som a++ tillater ikke en atomisk handling.
• Alle lese- og skriveoperasjoner for den primitive variabelen (unntatt lang og dobbel) er atomoperasjonen.
• All lese- og skriveoperasjon for den flyktige variabelen (inkludert lang og dobbel) er atomoperasjonen.
• Atomic-metodene er tilgjengelige i java.util.Concurrent-pakken.

40) Hva er låsegrensesnitt i Concurrency API i Java?

Java.util.concurrent.locks.Lock-grensesnittet brukes som synkroniseringsmekanisme. Den fungerer på samme måte som den synkroniserte blokken. Det er noen få forskjeller mellom låsen og synkronisert blokk som er gitt nedenfor.

• Låsgrensesnitt gir garanti for rekkefølgen der den ventende tråden vil få tilgang, mens den synkroniserte blokken ikke garanterer det.
• Låsgrensesnitt gir mulighet for tidsavbrudd hvis låsen ikke er gitt, mens den synkroniserte blokken ikke gir det.
• Metodene for låsegrensesnitt, det vil si Lock() og Unlock() kan kalles på forskjellige metoder, mens en enkelt synkronisert blokk må være fullstendig inneholdt i en enkelt metode.

41) Forklar ExecutorService-grensesnittet.

ExecutorService-grensesnittet er undergrensesnittet til Executor-grensesnittet og legger til funksjonene for å administrere livssyklusen. Tenk på følgende eksempel.

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

Produksjon

 Shutdown executor shutdown finished 

42) Hva er forskjellen mellom synkron programmering og asynkron programmering angående en tråd?

Synkron programmering: I synkron programmeringsmodell blir en tråd tildelt for å fullføre en oppgave, og tråden begynte derfor å jobbe med den, og den er bare tilgjengelig for andre oppgaver når den avslutter den tildelte oppgaven.

Asynkron programmering: I asynkron programmering kan en jobb fullføres av flere tråder og dermed gir den maksimal brukbarhet av de forskjellige trådene.

43) Hva forstår du med Callable and Future i Java?

Java Callable grensesnitt: I Java5 ble det anropbare grensesnittet levert av pakken java.util.concurrent. Det ligner på Runnable-grensesnittet, men det kan returnere et resultat, og det kan gi et unntak. Det gir også en run()-metode for utførelse av en tråd. Java Callable kan returnere hvilket som helst objekt ettersom det bruker Generic.

gimp fjern vannmerke

Syntaks:

offentlig grensesnitt Ringbar

Java Future-grensesnitt: Java Future-grensesnittet gir resultatet av en samtidig prosess. Callable-grensesnittet returnerer objektet til java.util.concurrent.Future.

Java Future gir følgende metoder for implementering.

cancel (boolean�kan avbryte hvis kjører):Den brukes til å avbryte utførelsen av den tildelte oppgaven.få():Den venter på tiden hvis utførelsen ikke er fullført og hentet deretter resultatet.er kansellert():Den returnerer den boolske verdien ettersom den returnerer sann hvis oppgaven ble kansellert før fullføringen.er ferdig():Den returnerer sann hvis jobben er fullført, ellers returnerer den falsk.

44. Hva er forskjellen mellom ScheduledExecutorService og ExecutorService grensesnitt?

ExecutorServcie og ScheduledExecutorService er begge grensesnittene til java.util.Concurrent-pakken, men scheduledExecutorService gir noen ekstra metoder for å utføre oppgavene Runnable og Callable med forsinkelsen eller hver faste tidsperiode.

45) Definer FutureTask-klassen i Java?

Java FutureTask-klassen gir en grunnleggende implementering av Future-grensesnittet. Resultatet kan bare oppnås hvis utførelsen av en oppgave er fullført, og hvis beregningen ikke oppnås, vil get-metoden bli blokkert. Hvis utførelsen er fullført, kan den ikke startes på nytt og kan ikke avbrytes.

Syntaks

offentlig klasse FutureTask utvider Objekt implementerer RunnableFuture