Multithreading og synkronisering betragtes som det typiske kapitel i java-programmering. I spiludviklingsvirksomheder stilles det meste af multithreading-relaterede interviewspørgsmål. En liste over ofte stillede java multithreading- og samtidighedsinterviewspørgsmål er givet nedenfor.

Multithreading interviewspørgsmål

1) Hvad er multithreading?

Multithreading er en proces med at udføre flere tråde samtidigt. Multithreading bruges til at opnå multitasking. Det bruger mindre hukommelse og giver den hurtige og effektive ydeevne. Dens vigtigste fordele er:

• Tråde deler det samme adresseområde.
• Tråden er let.
• Omkostningerne til kommunikation mellem processerne er lave.

2) Hvad er tråden?

En tråd er en let underproces. Det er en separat udførelsesvej, fordi hver tråd løber i en anden stakramme. En proces kan indeholde flere tråde. Tråde deler procesressourcerne, men alligevel udføres de uafhængigt.

3) Skel på proces og tråd?

Der er følgende forskelle mellem processen og tråden.

• Et program i udførelsen kaldes processen, hvorimod; En tråd er en delmængde af processen
• Processer er uafhængige, mens tråde er delmængden af ​​processen.
• Processen har forskellige adresserum i hukommelsen, mens tråde indeholder et delt adresserum.
• Kontekstskift er hurtigere mellem trådene sammenlignet med processer.
• Inter-proces kommunikation er langsommere og dyrt end inter-thread kommunikation.
• Enhver ændring i den overordnede proces påvirker ikke den underordnede proces, mens ændringer i den overordnede tråd kan påvirke den underordnede tråd.

4) Hvad forstår du ved kommunikation mellem tråde?

• Processen med kommunikation mellem synkroniserede tråde betegnes som kommunikation mellem tråde.
• Kommunikation mellem tråde bruges til at undgå trådafstemning i Java.
• Tråden er sat på pause i dens kritiske sektion, og en anden tråd får lov til at komme ind (eller låse) i den samme kritiske sektion for at blive udført.
• Det kan fås ved hjælp af wait(), notify() og notifyAll() metoder.

5) Hvad er formålet med wait()-metoden i Java?

wait()-metoden leveres af klassen Object i Java. Denne metode bruges til kommunikation mellem tråde i Java. java.lang.Object.wait() bruges til at sætte den aktuelle tråd på pause og vente, indtil en anden tråd ikke kalder notify() eller notifyAll() metoden. Dens syntaks er angivet nedenfor.

offentlig endelig ugyldig ventetid()

6) Hvorfor skal wait()-metoden kaldes fra den synkroniserede blok?

Vi må kalde ventemetoden ellers smider den java.lang.IllegalMonitorStateException undtagelse. Desuden har vi brug for wait()-metoden til inter-thread-kommunikation med notify() og notifyAll(). Derfor skal den være til stede i den synkroniserede blok for korrekt og korrekt kommunikation.

7) Hvad er fordelene ved multithreading?

Multithreading-programmering har følgende fordele:

• Multithreading gør det muligt for en applikation/program altid at være reaktiv for input, selv allerede kørende med nogle baggrundsopgaver
• Multithreading giver mulighed for hurtigere udførelse af opgaver, da tråde udføres uafhængigt.
• Multithreading giver bedre udnyttelse af cachehukommelsen, da tråde deler de fælles hukommelsesressourcer.
• Multithreading reducerer antallet af den nødvendige server, da en server kan udføre flere tråde ad gangen.

8) Hvilke tilstande er der i en tråds livscyklus?

En tråd kan have en af ​​følgende tilstande i løbet af sin levetid:

Ny:I denne tilstand oprettes et Thread-klasseobjekt ved hjælp af en ny operator, men tråden er ikke i live. Tråden starter ikke før vi kalder start() metoden.Kørbar:I denne tilstand er tråden klar til at køre efter at have kaldt start()-metoden. Tråden er dog endnu ikke valgt af trådplanlæggeren.Kører:I denne tilstand vælger trådplanlæggeren tråden fra klar-tilstanden, og tråden kører.Venter/blokeret:I denne tilstand kører en tråd ikke, men den er stadig i live, eller den venter på, at den anden tråd er færdig.Død/Afsluttet:En tråd er i afsluttet eller død tilstand, når run()-metoden afsluttes.

9) Hvad er forskellen mellem forebyggende planlægning og tidsudskæring?

Under forebyggende planlægning udføres opgaven med højeste prioritet, indtil den går ind i vente- eller dødtilstanden, eller en opgave med højere prioritet opstår. Under tidsudskæring udføres en opgave i et foruddefineret stykke tid og kommer derefter ind i puljen af ​​færdige opgaver igen. Planlæggeren bestemmer derefter, hvilken opgave der skal udføres næste gang, baseret på prioritet og andre faktorer.

10) Hvad er kontekstskifte?

I kontekstskift gemmes processens (eller trådens) tilstand, så den kan gendannes og udførelsen kan genoptages fra samme punkt senere. Kontekstskift gør det muligt for flere processer at dele den samme CPU.

11) Forskel mellem Thread-klassen og Runnable-grænsefladen til oprettelse af en Thread?

Tråden kan oprettes på to måder.

• Ved at udvide trådklassen
• Ved at implementere Runnable-grænsefladen

De primære forskelle mellem begge måder er dog angivet nedenfor:

• Ved at udvide Thread-klassen kan vi ikke udvide nogen anden klasse, da Java ikke tillader flere nedarvninger under implementering af Runnable-grænsefladen; vi kan også udvide anden basisklasse (hvis det kræves).
• Ved at udvide Thread-klassen opretter hver af trådene det unikke objekt og associerer med det, mens de implementerer Runnable-grænsefladen; flere tråde deler det samme objekt
• Trådklassen giver forskellige indbyggede metoder såsom getPriority(), isAlive og mange flere, mens Runnable-grænsefladen giver en enkelt metode, dvs. run().

12) Hvad betyder join()-metoden?

join()-metoden venter på, at en tråd dør. Med andre ord, det får de aktuelt kørende tråde til at stoppe med at køre, indtil tråden den forbinder med fuldfører sin opgave. Join-metoden er overbelastet i Thread-klassen på følgende måder.

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

13) Beskriv søvn()-metodens formål og virkemåde.

Sleep()-metoden i java bruges til at blokere en tråd i et bestemt tidsrum, hvilket betyder, at den pauser udførelsen af ​​en tråd i et bestemt tidsrum. Der er to metoder til at gøre det.

Syntaks:

kort med maskinskrift

• offentlig statisk tomrumssøvn (lange millisekunder) kaster InterruptedException
• offentlig statisk tom søvn (lange millisekunder, int nanos) kaster Afbrudt Undtagelse

Working of sleep() metode

Når vi kalder sleep()-metoden, sætter den udførelsen af ​​den aktuelle tråd på pause i det givne tidspunkt og prioriterer en anden tråd (hvis tilgængelig). Desuden, når ventetiden er afsluttet, ændrer den forrige tråd igen sin tilstand fra at vente til at køre og kommer i kørende tilstand, og hele processen fungerer, indtil udførelsen ikke er fuldført.

14) Hvad er forskellen mellem wait() og sleep() metoden?

15) Er det muligt at starte en tråd to gange?

Nej, vi kan ikke genstarte tråden, da når en tråd først er startet og udført, går den til Død tilstand. Derfor, hvis vi forsøger at starte en tråd to gange, vil den give en runtimeException 'java.lang.IllegalThreadStateException'. Overvej 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(); } } 

Produktion

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

Ja, at kalde run()-metoden direkte er gyldig, men den vil ikke fungere som en tråd i stedet for, den vil fungere som et normalt objekt. Der vil ikke være kontekst-switch mellem trådene. Når vi kalder start()-metoden, kalder den internt run()-metoden, som opretter en ny stak til en tråd, mens direkte kald af run() ikke vil skabe en ny stak.

eksempel binært søgetræ

17) Hvad med dæmontrådene?

Dæmon-trådene er de lavprioriterede tråde, der giver baggrundssupport og tjenester til brugertrådene. Daemon-tråden bliver automatisk afsluttet af JVM, hvis programmet kun forbliver med daemon-tråden, og alle andre brugertråde afsluttes/døde. Der er to metoder til dæmontråd tilgængelige i Thread-klassen:

public void setDaemon (boolesk status):Det plejede at markere tråddæmontråden eller en brugertråd.public boolean isDaemon():Det kontrollerer, at tråden er dæmon eller ej.

18)Kan vi lave brugertråden som dæmontråd, hvis tråden startes?

Nej, hvis du gør det, vil det kaste IllegalThreadStateException. Derfor kan vi kun oprette en dæmontrå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. } } 

Produktion

 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) Hvad er shutdown hook?

Nedlukningskrogen er en tråd, der påkaldes implicit, før JVM lukker ned. Så vi kan bruge det til at rense ressourcen eller gemme tilstanden, når JVM lukker ned normalt eller brat. Vi kan tilføje shutdown hook ved at bruge følgende metode:

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

Nogle vigtige punkter om nedlukningskroge er:

• Nedlukningskroge initialiseret, men kan kun startes, når JVM-nedlukningen fandt sted.
• Shutdown-hooks er mere pålidelige end finalizer(), fordi der er meget færre chancer for, at shutdown-hooks ikke kører.
• Nedlukningskrogen kan stoppes ved at kalde halt(int)-metoden i Runtime-klassen.

20) Hvornår skal vi afbryde en tråd?

Vi bør afbryde en tråd, når vi ønsker at bryde en tråds søvn- eller ventetilstand. Vi kan afbryde en tråd ved at kalde interrupt()�throwing InterruptedException.

21) Hvad er synkroniseringen?

Synkronisering er evnen til at kontrollere adgangen af ​​flere tråde til enhver delt ressource. Det bruges:

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

Når de flere tråde forsøger at udføre den samme opgave, er der mulighed for et fejlagtigt resultat, og for at fjerne dette problem bruger Java synkroniseringsprocessen, som tillader kun at udføre én tråd ad gangen. Synkronisering kan opnås på tre måder:

• ved den synkroniserede metode
• ved synkroniseret blok
• ved statisk synkronisering

Syntaks for synkroniseret blok

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

22) Hvad er formålet med den synkroniserede blok?

Den synkroniserede blok kan bruges til at udføre synkronisering på en hvilken som helst specifik ressource af metoden. Kun én tråd ad gangen kan udføres på en bestemt ressource, og alle andre tråde, der forsøger at komme ind i den synkroniserede blok, er blokeret.

• Synkroniseret blok bruges til at låse et objekt for enhver delt ressource.
• Omfanget af den synkroniserede blok er begrænset til den blok, hvorpå den anvendes. Dens omfang er mindre end en metode.

23)Kan Java-objekt låses ned til eksklusiv brug af en given tråd?

Ja. Du kan låse et objekt ved at sætte det i en 'synkroniseret' blok. Det låste objekt er utilgængeligt for enhver anden tråd end den, der eksplicit gjorde krav på det.

24) Hvad er statisk synkronisering?

Hvis du laver en statisk metode som synkroniseret, vil låsen være på klassen og ikke på objektet. Hvis vi bruger det synkroniserede nøgleord før en metode, så vil det låse objektet (en tråd kan få adgang til et objekt ad gangen), men hvis vi bruger statisk synkroniseret, så vil det låse en klasse (en tråd kan få adgang til en klasse ad gangen). Flere detaljer.

25) Hvad er forskellen mellem notify() og notifyAll()?

Notify() bruges til at fjerne blokeringen af ​​en ventende tråd, mens notifyAll() metoden bruges til at fjerne blokeringen af ​​alle tråde i ventetilstand.

26) Hvad er dødvandet?

Deadlock er en situation, hvor hver tråd venter på en ressource, som holdes af en anden ventende tråd. I denne situation udføres hverken af ​​tråden eller den får chancen for at blive henrettet. I stedet eksisterer der en universel ventetilstand blandt alle trådene. Deadlock er en meget kompliceret situation, som kan bryde vores kode under kørsel.

27) Hvordan opdager man en deadlock-tilstand? Hvordan kan det undgås?

Vi kan detektere deadlock-tilstanden ved at køre koden på cmd og indsamle Thread Dump, og hvis der er nogen deadlock til stede i koden, så vises en besked på cmd.

Måder at undgå dødvandetilstanden i Java:

Undgå indlejret lås:Indlejret lås er den almindelige årsag til dødvande, da dødvande opstår, når vi leverer låse til forskellige tråde, så vi bør give én lås til kun én tråd på et bestemt tidspunkt.Undgå unødvendige låse:vi skal undgå de låse, som ikke er påkrævet.Brug af trådsammenføjning:Thread join hjælper med at vente på en tråd, indtil en anden tråd ikke afslutter sin udførelse, så vi kan undgå deadlock ved maksimal brug af join-metoden.

28) Hvad er Thread Scheduler i java?

I Java, når vi opretter trådene, bliver de overvåget ved hjælp af en Thread Scheduler, som er en del af JVM. Trådplanlæggeren er kun ansvarlig for at beslutte, hvilken tråd der skal udføres. Trådplanlæggeren bruger to mekanismer til at planlægge trådene: Forebyggende og tidsudskæring.

• Den vælger trådens prioritet.
• Det bestemmer ventetiden på en tråd
• Det tjekker trådens natur

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

Ja, i flertrådsprogrammering bevarer hver tråd sit eget eller separate stackområde i hukommelsen, på grund af hvilket hver tråd er uafhængig af hinanden.

30) Hvordan opnås sikkerheden for en tråd?

Hvis en metode eller et klasseobjekt kan bruges af flere tråde ad gangen uden nogen racebetingelse, så er klassen trådsikker. Trådsikkerhed bruges til at gøre et program sikkert at bruge i flertrådsprogrammering. Det kan opnås på følgende måder:

• Synkronisering
• Brug af flygtigt søgeord
• Brug af en låsebaseret mekanisme
• Brug af atomindpakningsklasser

31) Hvad er race-tilstand?

En race-tilstand er et problem, der opstår i flertrådsprogrammering, når forskellige tråde udføres samtidigt og får adgang til en delt ressource på samme tid. Korrekt brug af synkronisering kan undgå Race-tilstanden.

32) Hvad er det flygtige søgeord i java?

Flygtigt nøgleord bruges i flertrådsprogrammering for at opnå trådsikkerheden, da en ændring i én flygtig variabel er synlig for alle andre tråde, så én variabel kan bruges af én tråd ad gangen.

33) Hvad forstår du ved trådpulje?

• Java Thread pool repræsenterer en gruppe af arbejdstråde, som venter på, at opgaven bliver tildelt.
• Tråde i trådpuljen overvåges af tjenesteudbyderen, som trækker en tråd fra puljen og tildeler den et job.
• Efter afslutning af den givne opgave kom tråden igen til trådpuljen.
• Størrelsen af ​​trådpuljen afhænger af det samlede antal tråde, der er reserveret til udførelse.

Fordelene ved trådpuljen er:

• Ved at bruge en trådpulje kan ydeevnen forbedres.
• Ved at bruge en trådpulje kan der opstå bedre systemstabilitet.

Spørgsmål til samtidighedsinterview

34) Hvad er hovedkomponenterne i concurrency API?

Concurrency API kan udvikles ved hjælp af klassen og grænseflader i java.util.Concurrent-pakken. Der er følgende klasser og grænseflader i pakken java.util.Concurrent.

• Eksekutør
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Fremtid
• TimeUnit (Enum)
• CountDownLatch
• CyclicBarrier
• Semafor
• ThreadFactory
• Blokeringskø
• Delay Queue
• Låse
• Phaser

35) Hvad er Executor-grænsefladen i Concurrency API i Java?

Executor-grænsefladen leveret af pakken java.util.concurrent er den enkle grænseflade, der bruges til at udføre den nye opgave. execute()-metoden i Executor-grænsefladen bruges til at udføre en given kommando. Syntaksen for execute()-metoden er angivet nedenfor.

void execute (kørbar kommando)

java switch erklæring

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

Produktion

 Running Thread! Thread Completed 

36) Hvad er BlockingQueue?

java.util.concurrent.BlockingQueue er undergrænsefladen til Queue, der understøtter operationer, såsom at vente på ledig plads, før der indsættes en ny værdi, eller at vente på, at køen ikke bliver tom, før der hentes et element fra den. Overvej 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(); } } } } 

Produktion

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

37) Hvordan implementerer man et producent-forbrugerproblem ved at bruge BlockingQueue?

Producent-forbruger problemet kan løses ved at bruge BlockingQueue på følgende måde.

 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) Hvad er forskellen mellem Java Callable interface og Runnable interface?

Den Callable-grænseflade og Runnable-grænsefladen bruges begge af de klasser, der ønskede at udføre med flere tråde. Der er dog to hovedforskelle mellem de to:

• En Callable-grænseflade kan returnere et resultat, mens den Runnable-grænseflade ikke kan returnere noget resultat.
• En Callable-grænseflade kan give en markeret undtagelse, mens den Runnable-grænseflade ikke kan give en markeret undtagelse.
• En Callable-grænseflade kan ikke bruges før Java 5, mens den Runnable-grænseflade kan bruges.

39) Hvad er atomhandlingen i samtidighed i Java?

• Atomhandlingen er den operation, der kan udføres i en enkelt enhed af en opgave uden indblanding fra de andre operationer.
• Atomic-handlingen kan ikke stoppes mellem opgaven. Når den først er startet, stopper den kun efter afslutningen af ​​opgaven.
• En inkrementoperation såsom a++ tillader ikke en atomart handling.
• Alle læse- og skriveoperationer for den primitive variabel (undtagen lang og dobbelt) er atomoperationen.
• Alle læse- og skriveoperationer for den flygtige variabel (inklusive lang og dobbelt) er atomoperationen.
• Atomic-metoderne er tilgængelige i java.util.Concurrent-pakken.

40) Hvad er låsegrænseflade i Concurrency API i Java?

Java.util.concurrent.locks.Lock-grænsefladen bruges som synkroniseringsmekanisme. Det fungerer på samme måde som den synkroniserede blok. Der er nogle få forskelle mellem låsen og den synkroniserede blok, der er angivet nedenfor.

• Lås interface giver garanti for rækkefølgen, hvori den ventende tråd vil få adgang, mens den synkroniserede blok ikke garanterer det.
• Låsgrænseflade giver mulighed for timeout, hvis låsen ikke er givet, mens den synkroniserede blok ikke giver det.
• Metoderne til Lock interface, dvs. Lock() og Unlock() kan kaldes på forskellige måder, mens en enkelt synkroniseret blok skal være fuldt ud indeholdt i en enkelt metode.

41) Forklar ExecutorService-grænsefladen.

ExecutorService-grænsefladen er undergrænsefladen til Executor-grænsefladen og tilføjer funktionerne til at styre livscyklussen. Overvej 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(); } } } } 

Produktion

 Shutdown executor shutdown finished 

42) Hvad er forskellen mellem synkron programmering og asynkron programmering vedrørende en tråd?

Synkron programmering: I synkron programmeringsmodel er en tråd tildelt til at fuldføre en opgave, og tråden begyndte derfor at arbejde på den, og den er kun tilgængelig for andre opgaver, når den afslutter den tildelte opgave.

Asynkron programmering: I asynkron programmering kan et job fuldføres af flere tråde, og det giver derfor maksimal anvendelighed af de forskellige tråde.

43) Hvad forstår du ved Callable og Future i Java?

Java Callable grænseflade: I Java5 blev kaldbar grænseflade leveret af pakken java.util.concurrent. Det ligner Runnable-grænsefladen, men det kan returnere et resultat, og det kan give en undtagelse. Det giver også en run()-metode til udførelse af en tråd. Java Callable kan returnere ethvert objekt, da det bruger Generic.

Linux gratis ipconfig

Syntaks:

offentlig grænseflade Kaldbar

Java Future-grænseflade: Java Future-grænseflade giver resultatet af en samtidig proces. Den Callable-grænseflade returnerer objektet i java.util.concurrent.Future.

Java Future giver følgende metoder til implementering.

annuller (boolean�kan afbryde hvis kører):Den bruges til at annullere udførelsen af ​​den tildelte opgave.få():Den venter på tidspunktet, hvis eksekveringen ikke er fuldført, og hentede derefter resultatet.er annulleret():Den returnerer den boolske værdi, da den returnerer sand, hvis opgaven blev annulleret før afslutningen.Er gjort():Det returnerer sandt, hvis jobbet er fuldført med succes, ellers returnerer det falsk.

44. Hvad er forskellen mellem ScheduledExecutorService og ExecutorService-grænsefladen?

ExecutorServcie og ScheduledExecutorService er begge grænseflader til java.util.Concurrent-pakken, men scheduledExecutorService giver nogle yderligere metoder til at udføre de Runnable og Callable-opgaver med forsinkelsen eller hver fast tidsperiode.

45) Definer FutureTask klasse i Java?

Java FutureTask-klassen giver en basisimplementering af Future-grænsefladen. Resultatet kan kun opnås, hvis udførelsen af ​​én opgave er fuldført, og hvis beregningen ikke opnås, vil get-metoden blive blokeret. Hvis udførelsen er fuldført, kan den ikke genstartes og kan ikke annulleres.

Syntaks

public class FutureTask udvider Objekt implementerer RunnableFuture