TechCodeview

Multithreading och Synchronization anses vara det typiska kapitlet i java-programmering. I spelutvecklingsföretag ställs mestadels multithreading-relaterade intervjufrågor. En lista över vanliga frågor om java multithreading och samtidighetsintervjuer ges nedan.

Flertrådsintervjufrågor

1) Vad är multithreading?

Multithreading är en process där flera trådar körs samtidigt. Multitrådning används för att få multitasking. Den förbrukar mindre minne och ger snabb och effektiv prestanda. Dess främsta fördelar är:

• Trådar delar samma adressutrymme.
• Tråden är lätt.
• Kostnaden för kommunikation mellan processerna är låg.

2) Vad är tråden?

En tråd är en lätt delprocess. Det är en separat väg för utförande eftersom varje tråd löper i en annan stackram. En process kan innehålla flera trådar. Trådar delar på processresurserna, men de körs ändå oberoende.

3) Skiljer på process och tråd?

Det finns följande skillnader mellan processen och tråden.

• Ett program i exekveringen kallas processen medan; En tråd är en delmängd av processen
• Processer är oberoende medan trådar är en delmängd av processen.
• Processen har olika adressutrymme i minnet, medan trådar innehåller ett delat adressutrymme.
• Kontextväxling är snabbare mellan trådarna jämfört med processer.
• Kommunikation mellan processer är långsammare och dyrare än kommunikation mellan trådar.
• Alla ändringar i den överordnade processen påverkar inte den underordnade processen medan ändringar i den överordnade tråden kan påverka den underordnade tråden.

4) Vad förstår du med kommunikation mellan trådar?

• Processen för kommunikation mellan synkroniserade trådar betecknas som kommunikation mellan trådar.
• Kommunikation mellan trådar används för att undvika trådpolling i Java.
• Tråden pausas i sin kritiska sektion, och en annan tråd tillåts komma in (eller låsa) i samma kritiska sektion för att köras.
• Det kan erhållas med metoderna wait(), notify() och notifyAll().

5) Vad är syftet med metoden wait() i Java?

Metoden wait() tillhandahålls av klassen Object i Java. Denna metod används för kommunikation mellan trådar i Java. Java.lang.Object.wait() används för att pausa den aktuella tråden och vänta tills en annan tråd inte anropar notify()- eller notifyAll()-metoden. Dess syntax anges nedan.

public final void wait()

6) Varför måste metoden wait() anropas från det synkroniserade blocket?

Vi måste kalla väntemetoden annars kommer det att kasta java.lang.IllegalMonitorStateException undantag. Dessutom behöver vi metoden wait() för kommunikation mellan trådar med notify() och notifyAll(). Därför måste den finnas i det synkroniserade blocket för korrekt och korrekt kommunikation.

7) Vilka är fördelarna med multithreading?

Flertrådsprogrammering har följande fördelar:

• Multithreading gör att en applikation/program alltid kan vara reaktiv för inmatning, även om den redan körs med vissa bakgrundsuppgifter
• Multithreading möjliggör snabbare exekvering av uppgifter, eftersom trådar körs oberoende.
• Multithreading ger bättre utnyttjande av cacheminnet eftersom trådar delar de gemensamma minnesresurserna.
• Multithreading minskar antalet nödvändiga server eftersom en server kan köra flera trådar åt gången.

8) Vilka är tillstånden i livscykeln för en tråd?

En tråd kan ha ett av följande tillstånd under sin livstid:

Ny:I detta tillstånd skapas ett Thread-klassobjekt med en ny operator, men tråden är inte levande. Tråden startar inte förrän vi anropar start()-metoden.Körbar:I detta tillstånd är tråden redo att köras efter att ha anropat start()-metoden. Tråden är dock inte vald av trådschemaläggaren ännu.Löpning:I det här läget väljer trådschemaläggaren tråden från redoläget och tråden körs.Väntar/blockerad:I det här tillståndet körs inte en tråd men den lever fortfarande, eller så väntar den på att den andra tråden ska avslutas.Död/avslutad:En tråd är i avslutat eller dött tillstånd när run()-metoden avslutas.

9) Vad är skillnaden mellan förebyggande schemaläggning och tidsindelning?

Under förebyggande schemaläggning körs den högst prioriterade uppgiften tills den går in i väntande eller döda tillstånd eller en högre prioritetsuppgift uppstår. Under tidsdelning körs en uppgift under en fördefinierad tidsperiod och går sedan in i poolen av färdiga uppgifter igen. Schemaläggaren bestämmer sedan vilken uppgift som ska utföras härnäst, baserat på prioritet och andra faktorer.

10) Vad är kontextbyte?

I kontextväxling lagras processens (eller trådens) tillstånd så att den kan återställas och exekveringen kan återupptas från samma punkt senare. Kontextväxling gör det möjligt för flera processer att dela samma CPU.

11) Skiljer på trådklassen och körbart gränssnitt för att skapa en tråd?

Tråden kan skapas på två sätt.

• Genom att utöka klassen Tråd
• Genom att implementera Runnable-gränssnittet

Men de primära skillnaderna mellan de båda sätten ges nedan:

• Genom att utöka klassen Thread kan vi inte utöka någon annan klass, eftersom Java inte tillåter flera arv medan vi implementerar Runnable-gränssnittet; vi kan även utöka andra basklasser (om det behövs).
• Genom att utöka klassen Thread skapar var och en av trådarna det unika objektet och associeras med det samtidigt som det körbara gränssnittet implementeras; flera trådar delar samma objekt
• Trådklassen tillhandahåller olika inbyggda metoder som getPriority(), isAlive och många fler medan Runnable-gränssnittet tillhandahåller en enda metod, dvs run().

12) Vad innebär join()-metoden?

Metoden join() väntar på att en tråd ska dö. Med andra ord får de trådar som körs för närvarande att sluta köras tills tråden den ansluter sig till slutför sin uppgift. Join-metoden är överbelastad i Thread-klassen på följande sätt.

• public void join() kastar InterruptedException
• public void join (långa millisekunder) kastar InterruptedException

13) Beskriv syftet och hur sömnmetoden() fungerar.

Sleep()-metoden i java används för att blockera en tråd för en viss tid, vilket innebär att den pausar exekveringen av en tråd under en viss tid. Det finns två sätt att göra det på.

Syntax:

hög och hög sort

• offentlig statisk void sömn (långa millisekunder) kastar InterruptedException
• offentlig statisk void sömn (långa millisekunder, int nanos) kastar avbruten undantag

Working of sleep()-metoden

När vi anropar metoden sleep() pausar den exekveringen av den aktuella tråden under den givna tiden och prioriterar en annan tråd (om tillgänglig). Dessutom, när väntetiden slutförts, ändrar den föregående tråden igen sitt tillstånd från väntande till körbart och kommer i körningsläge, och hela processen fungerar så vidare tills exekveringen inte slutförs.

14) Vad är skillnaden mellan metoden wait() och sleep()?

15) Är det möjligt att starta en tråd två gånger?

Nej, vi kan inte starta om tråden, eftersom när en tråd startas och körs går den till Död-tillståndet. Därför, om vi försöker starta en tråd två gånger, kommer den att ge en runtimeException 'java.lang.IllegalThreadStateException'. Betrakta följande exempel.

 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 anropa run()-metoden istället för start()?

Ja, att anropa run()-metoden direkt är giltigt, men det kommer inte att fungera som en tråd istället kommer det att fungera som ett normalt objekt. Det kommer inte att ske kontextväxling mellan trådarna. När vi anropar start()-metoden anropar den internt run()-metoden, vilket skapar en ny stack för en tråd medan direkt anrop av run() inte kommer att skapa en ny stack.

17) Hur är det med demontrådarna?

Demontrådarna är de lågprioriterade trådarna som tillhandahåller bakgrundsstöd och tjänster till användartrådarna. Daemon-tråden avslutas automatiskt av JVM om programmet bara finns kvar med demon-tråden, och alla andra användartrådar avslutas/dör. Det finns två metoder för demontråd tillgängliga i klassen Thread:

public void setDaemon(boolesk status):Det brukade markera tråddemonstråden eller en användartråd.public boolean isDaemon():Den kontrollerar att tråden är demon eller inte.

18)Kan vi göra användartråden som demontråd om tråden startas?

Nej, om du gör det kommer det att kasta IllegalThreadStateException. Därför kan vi bara skapa en demontråd innan vi startar 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) Vad är avstängningskrok?

Avstängningskroken är en tråd som anropas implicit innan JVM stängs av. Så vi kan använda den för att rensa upp resursen eller spara tillståndet när JVM stängs av normalt eller abrupt. Vi kan lägga till avstängningskrok genom att använda följande metod:

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

Några viktiga punkter om avstängningskrokar är:

• Avstängningskrokar initierades men kan bara startas när JVM-avstängning inträffade.
• Shutdown hooks är mer tillförlitliga än finalizer() eftersom det finns mycket färre chanser att avstängningskrokar inte körs.
• Avstängningskroken kan stoppas genom att anropa halt(int)-metoden för Runtime-klassen.

20) När ska vi avbryta en tråd?

Vi bör avbryta en tråd när vi vill bryta sömn- eller väntatillståndet för en tråd. Vi kan avbryta en tråd genom att anropa interrupt()�throwing InterruptedException.

21) Vad är synkroniseringen?

Synkronisering är förmågan att kontrollera åtkomsten av flera trådar till valfri delad resurs. Den är använd:

1. För att förhindra trådstörningar.
2. För att förhindra konsistensproblem.

När flera trådar försöker göra samma uppgift finns det en risk för ett felaktigt resultat, för att ta bort problemet använder Java synkroniseringsprocessen som tillåter att endast en tråd körs åt gången. Synkronisering kan uppnås på tre sätt:

kamelfodral python

• med den synkroniserade metoden
• genom synkroniserat block
• genom statisk synkronisering

Syntax för synkroniserat block

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

22) Vad är syftet med det synkroniserade blocket?

Det synkroniserade blocket kan användas för att utföra synkronisering på vilken specifik resurs som helst av metoden. Endast en tråd åt gången kan köras på en viss resurs, och alla andra trådar som försöker komma in i det synkroniserade blocket blockeras.

• Synkroniserat block används för att låsa ett objekt för valfri delad resurs.
• Omfattningen av det synkroniserade blocket är begränsat till det block på vilket det appliceras. Dess omfattning är mindre än en metod.

23) Kan Java-objekt låsas för exklusiv användning av en given tråd?

Ja. Du kan låsa ett objekt genom att placera det i ett 'synkroniserat' block. Det låsta objektet är oåtkomligt för någon annan tråd än den som uttryckligen hävdade det.

24) Vad är statisk synkronisering?

Om du gör någon statisk metod som synkroniserad, kommer låset att vara på klassen inte på objektet. Om vi ​​använder det synkroniserade nyckelordet före en metod så kommer det att låsa objektet (en tråd kan komma åt ett objekt åt gången) men om vi använder statisk synkroniserad så kommer det att låsa en klass (en tråd kan komma åt en klass åt gången). Fler detaljer.

25)Vad är skillnaden mellan notify() och notifyAll()?

Notify() används för att avblockera en väntande tråd medan notifyAll()-metoden används för att avblockera alla trådar i väntande tillstånd.

tostring-metoden

26) Vad är dödläget?

Deadlock är en situation där varje tråd väntar på en resurs som hålls av någon annan väntande tråd. I den här situationen körs ingen av tråden eller den får chansen att köras. Istället finns det ett universellt väntetillstånd bland alla trådar. Deadlock är en mycket komplicerad situation som kan bryta vår kod under körning.

27) Hur upptäcker man ett dödläge? Hur kan det undvikas?

Vi kan upptäcka dödläget genom att köra koden på cmd och samla in tråddumpen, och om något dödläge finns i koden kommer ett meddelande att visas på cmd.

Sätt att undvika dödläget i Java:

Undvik kapslat lås:Kapslad lås är den vanliga orsaken till dödläge eftersom låsning uppstår när vi tillhandahåller lås till olika trådar så vi bör ge ett lås till endast en tråd vid en viss tidpunkt.Undvik onödiga lås:vi måste undvika de lås som inte krävs.Använda trådkoppling:Trådkoppling hjälper till att vänta på en tråd tills en annan tråd inte avslutar sin körning så vi kan undvika dödläge genom att maximalt använda kopplingsmetoden.

28) Vad är Thread Scheduler i java?

I Java, när vi skapar trådarna, övervakas de med hjälp av en Thread Scheduler, som är en del av JVM. Trådschemaläggaren är endast ansvarig för att bestämma vilken tråd som ska köras. Trådschemaläggaren använder två mekanismer för att schemalägga trådarna: Preemptive och Time Slicing.

• Den väljer prioritet för tråden.
• Det bestämmer väntetiden för en tråd
• Den kontrollerar trådens natur

29) Har varje tråd sin stack i flertrådsprogrammering?

Ja, i flertrådsprogrammering bibehåller varje tråd sitt eget eller separata stackområde i minnet på grund av vilket varje tråd är oberoende av varandra.

30) Hur uppnås säkerheten för en tråd?

Om en metod eller ett klassobjekt kan användas av flera trådar samtidigt utan något rasvillkor, är klassen trådsäker. Trådsäkerhet används för att göra ett program säkert att använda i flertrådsprogrammering. Det kan uppnås på följande sätt:

• Synkronisering
• Använder flyktigt nyckelord
• Använder en låsbaserad mekanism
• Användning av atomomslagsklasser

31) Vad är race-condition?

Ett race-tillstånd är ett problem som uppstår i flertrådsprogrammering när olika trådar körs samtidigt och åtkomst till en delad resurs samtidigt. Korrekt användning av synkronisering kan undvika Race-tillståndet.

32) Vad är det flyktiga nyckelordet i java?

Volatile nyckelord används i flertrådsprogrammering för att uppnå trådsäkerheten, eftersom en förändring i en flyktig variabel är synlig för alla andra trådar så en variabel kan användas av en tråd åt gången.

33) Vad förstår du med trådpool?

• Java Trådpool representerar en grupp arbetartrådar som väntar på att uppgiften ska tilldelas.
• Trådar i trådpoolen övervakas av tjänsteleverantören som drar en tråd från poolen och tilldelar den ett jobb.
• Efter slutförandet av den givna uppgiften kom tråden igen till trådpoolen.
• Trådpoolens storlek beror på det totala antalet trådar som hålls reserverade för utförande.

Fördelarna med trådpoolen är:

• Genom att använda en trådpool kan prestandan förbättras.
• Med hjälp av en trådpool kan bättre systemstabilitet uppstå.

Samtidighetsintervjufrågor

34) Vilka är huvudkomponenterna i concurrency API?

Concurrency API kan utvecklas med klassen och gränssnitten för java.util.Concurrent-paketet. Det finns följande klasser och gränssnitt i paketet java.util.Concurrent.

• Testamentsexekutor
• FarkJoinPool
• ExecutorService
• ScheduledExecutorService
• Framtida
• Tidsenhet (Enum)
• CountdownLatch
• CyclicBarrier
• Semafor
• ThreadFactory
• BlockingQueue
• DelayQueue
• Lås
• Phaser

35) Vad är Executor-gränssnittet i Concurrency API i Java?

Executor Interface som tillhandahålls av paketet java.util.concurrent är det enkla gränssnittet som används för att utföra den nya uppgiften. Metoden execute() i Executor-gränssnittet används för att utföra ett givet kommando. Syntaxen för metoden execute() ges nedan.

void execute (körbart kommando)

Tänk på följande exempel:

 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) Vad är BlockingQueue?

Java.util.concurrent.BlockingQueue är undergränssnittet till Queue som stöder operationer som att vänta på utrymmestillgänglighet innan ett nytt värde infogas eller att vänta på att kön inte blir tom innan du hämtar ett element från det. Betrakta följande exempel.

 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) Hur implementerar man producent-konsumentproblem genom att använda BlockingQueue?

Producent-konsumentproblemet kan lösas genom att använda BlockingQueue på följande sätt.

 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) Vad är skillnaden mellan Java Callable-gränssnitt och Runnable-gränssnitt?

Det anropbara gränssnittet och det körbara gränssnittet används båda av klasserna som ville köra med flera trådar. Det finns dock två huvudsakliga skillnader mellan de båda:

• Ett Callable-gränssnitt kan returnera ett resultat, medan det Runnable-gränssnittet inte kan returnera något resultat.
• Ett anropsbart gränssnitt kan skicka ett markerat undantag, medan det körbara gränssnittet inte kan skicka ett markerat undantag.
• Ett Callable-gränssnitt kan inte användas före Java 5 medan det Runnable-gränssnittet kan användas.

39) Vad är Atomic Action i Concurrency i Java?

• Atomåtgärden är operationen som kan utföras i en enda enhet av en uppgift utan någon inblandning av de andra operationerna.
• Atomic-åtgärden kan inte stoppas mellan uppgiften. När den väl har startat, stoppar den bara efter att uppgiften är klar.
• En inkrementoperation som a++ tillåter inte en atomär verkan.
• All läs- och skrivoperation för den primitiva variabeln (förutom lång och dubbel) är atomoperationen.
• All läs- och skrivoperation för den flyktiga variabeln (inklusive lång och dubbel) är atomoperationen.
• Atomic-metoderna är tillgängliga i paketet java.util.Concurrent.

40) Vad är låsgränssnitt i Concurrency API i Java?

Gränssnittet java.util.concurrent.locks.Lock används som synkroniseringsmekanism. Det fungerar på samma sätt som det synkroniserade blocket. Det finns några skillnader mellan låset och synkroniserat block som ges nedan.

• Låsgränssnittet ger garanti för sekvensen i vilken den väntande tråden kommer att ges åtkomst, medan det synkroniserade blocket inte garanterar det.
• Låsgränssnitt ger möjlighet till timeout om låset inte beviljas medan det synkroniserade blocket inte ger det.
• Metoderna för låsgränssnitt, det vill säga Lock() och Unlock() kan anropas i olika metoder medan ett enda synkroniserat block måste innehållas helt i en enda metod.

41) Förklara ExecutorService-gränssnittet.

ExecutorService-gränssnittet är undergränssnittet till Executor-gränssnittet och lägger till funktioner för att hantera livscykeln. Betrakta följande exempel.

 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) Vad är skillnaden mellan synkron programmering och asynkron programmering angående en tråd?

Synkron programmering: I modellen för synkron programmering tilldelas en tråd att slutföra en uppgift och därför började tråden arbeta på den, och den är endast tillgänglig för andra uppgifter när den avslutar den tilldelade uppgiften.

Asynkron programmering: I asynkron programmering kan ett jobb slutföras av flera trådar och därför ger det maximal användbarhet för de olika trådarna.

43) Vad förstår du med Callable and Future i Java?

Java Callable gränssnitt: I Java5 tillhandahölls anropsbart gränssnitt av paketet java.util.concurrent. Det liknar Runnable-gränssnittet men det kan returnera ett resultat och det kan skapa ett undantag. Den tillhandahåller också en run()-metod för exekvering av en tråd. Java Callable kan returnera vilket objekt som helst eftersom det använder Generic.

Syntax:

offentligt gränssnitt Callable

Java Future-gränssnitt: Java Future-gränssnittet ger resultatet av en samtidig process. Det Callable-gränssnitt returnerar objektet för java.util.concurrent.Future.

Java Future tillhandahåller följande metoder för implementering.

returnerar en array-java

avbryt (boolean�kan avbryta om körs):Den används för att avbryta utförandet av den tilldelade uppgiften.skaffa sig():Den väntar på tiden om exekveringen inte slutförts och hämtade sedan resultatet.isCancelled():Det returnerar det booleska värdet eftersom det returnerar sant om uppgiften avbröts innan slutförandet.är klart():Det returnerar sant om jobbet slutförs framgångsrikt annars returneras falskt.

44. Vad är skillnaden mellan ScheduledExecutorService och ExecutorService-gränssnittet?

ExecutorServcie och ScheduledExecutorService är båda gränssnitten för java.util.Concurrent-paketet men scheduledExecutorService tillhandahåller några ytterligare metoder för att utföra de körbara och anropbara uppgifterna med fördröjningen eller varje fast tidsperiod.

45) Definiera FutureTask-klassen i Java?

Java FutureTask-klassen tillhandahåller en basimplementering av Future-gränssnittet. Resultatet kan endast erhållas om exekveringen av en uppgift är klar, och om beräkningen inte uppnås kommer get-metoden att blockeras. Om exekveringen är klar kan den inte startas om och kan inte avbrytas.

Syntax

public class FutureTask utökar Objekt implementerar RunnableFuture