TechCodeview

Multithreading en synchronisatie worden beschouwd als het typische hoofdstuk in Java-programmering. Bij game-ontwikkelingsbedrijven worden vooral multithreading-gerelateerde interviewvragen gesteld. Hieronder vindt u een lijst met veelgestelde vragen over Java-multithreading en concurrency-interviews.

Interviewvragen met meerdere threads

1) Wat is multithreading?

Multithreading is een proces waarbij meerdere threads tegelijkertijd worden uitgevoerd. Multithreading wordt gebruikt om multitasking te verkrijgen. Het verbruikt minder geheugen en levert snelle en efficiënte prestaties. De belangrijkste voordelen zijn:

• Threads delen dezelfde adresruimte.
• De draad is lichtgewicht.
• De kosten van communicatie tussen de processen zijn laag.

2) Wat is de draad?

Een thread is een lichtgewicht subproces. Het is een apart uitvoeringspad omdat elke thread in een ander stapelframe loopt. Een proces kan meerdere threads bevatten. Threads delen de procesbronnen, maar worden toch onafhankelijk uitgevoerd.

3) Onderscheid maken tussen proces en draad?

Er zijn de volgende verschillen tussen het proces en de thread.

• Een programma in de uitvoering wordt het proces genoemd, terwijl; Een thread is een subset van het proces
• Processen zijn onafhankelijk, terwijl threads de subset van processen vormen.
• Processen hebben verschillende adresruimte in het geheugen, terwijl threads een gedeelde adresruimte bevatten.
• Het wisselen van context is sneller tussen de threads in vergelijking met processen.
• Communicatie tussen processen is langzamer en duurder dan communicatie tussen threads.
• Elke wijziging in het bovenliggende proces heeft geen invloed op het onderliggende proces, terwijl wijzigingen in de bovenliggende thread wel invloed kunnen hebben op de onderliggende thread.

4) Wat verstaat u onder communicatie tussen threads?

• Het communicatieproces tussen gesynchroniseerde threads wordt communicatie tussen threads genoemd.
• Communicatie tussen threads wordt gebruikt om thread polling in Java te voorkomen.
• De thread wordt gepauzeerd in zijn kritieke sectie, en een andere thread mag dezelfde kritieke sectie binnenkomen (of vergrendelen) om te worden uitgevoerd.
• Het kan worden verkregen met de methoden wait(), kennisgeving() en kennisgevingAll().

5) Wat is het doel van de wait()-methode in Java?

De wait()-methode wordt geleverd door de Object-klasse in Java. Deze methode wordt gebruikt voor communicatie tussen threads in Java. De java.lang.Object.wait() wordt gebruikt om de huidige thread te pauzeren en te wachten totdat een andere thread de methode require() of notifyAll() niet aanroept. De syntaxis ervan wordt hieronder gegeven.

openbare definitieve leegte wait()

6) Waarom moet de wait()-methode worden aangeroepen vanuit het gesynchroniseerde blok?

We moeten de wait-methode aanroepen, anders wordt er gegooid java.lang.IllegalMonitorStateException uitzondering. Bovendien hebben we de wait()-methode nodig voor communicatie tussen threads met kennisgeving() en notificatieAll(). Daarom moet het aanwezig zijn in het gesynchroniseerde blok voor een goede en correcte communicatie.

7) Wat zijn de voordelen van multithreading?

Multithreading programmeren heeft de volgende voordelen:

• Multithreading zorgt ervoor dat een applicatie/programma altijd reactief is voor invoer, zelfs al actief met enkele achtergrondtaken
• Multithreading maakt een snellere uitvoering van taken mogelijk, omdat threads onafhankelijk worden uitgevoerd.
• Multithreading zorgt voor een beter gebruik van cachegeheugen, omdat threads de gemeenschappelijke geheugenbronnen delen.
• Multithreading vermindert het aantal benodigde servers, omdat één server meerdere threads tegelijk kan uitvoeren.

8) Wat zijn de statussen in de levenscyclus van een thread?

Een thread kan tijdens zijn levensduur een van de volgende statussen hebben:

Nieuw:In deze toestand wordt een Thread-klasseobject gemaakt met behulp van een nieuwe operator, maar de thread leeft niet. Thread start pas als we de methode start() aanroepen.Uitvoerbaar:In deze status is de thread klaar om te worden uitgevoerd nadat de methode start() is aangeroepen. De thread is echter nog niet geselecteerd door de threadplanner.Rennen:In deze status kiest de threadplanner de thread vanuit de gereedstatus en wordt de thread uitgevoerd.Wachten/geblokkeerd:In deze status is een thread niet actief, maar nog steeds in leven, of wacht deze tot de andere thread is voltooid.Dood/beëindigd:Een thread bevindt zich in de beëindigde of dode status wanneer de methode run() wordt afgesloten.

9) Wat is het verschil tussen preventieve planning en time-slicing?

Bij preventieve planning wordt de taak met de hoogste prioriteit uitgevoerd totdat deze in de wacht- of dode toestand komt of totdat een taak met een hogere prioriteit ontstaat. Bij time-slicing wordt een taak gedurende een vooraf gedefinieerd tijdsbestek uitgevoerd en komt vervolgens opnieuw in de pool met gereedstaande taken terecht. De planner bepaalt vervolgens welke taak als volgende moet worden uitgevoerd, op basis van prioriteit en andere factoren.

10) Wat is contextwisseling?

Bij Context-switching wordt de status van het proces (of de thread) opgeslagen, zodat deze kan worden hersteld en de uitvoering later vanaf hetzelfde punt kan worden hervat. Contextwisseling zorgt ervoor dat meerdere processen dezelfde CPU kunnen delen.

11) Maak onderscheid tussen de Thread-klasse en de Runnable-interface voor het maken van een Thread?

De Thread kan op twee manieren worden gemaakt.

• Door de Thread-klasse uit te breiden
• Door de Runnable-interface te implementeren

De belangrijkste verschillen tussen beide manieren worden echter hieronder weergegeven:

• Door de klasse Thread uit te breiden, kunnen we geen enkele andere klasse uitbreiden, omdat Java geen meerdere overervingen toestaat tijdens de implementatie van de Runnable-interface; we kunnen ook andere basisklassen uitbreiden (indien nodig).
• Door de klasse Thread uit te breiden, creëert elke thread het unieke object en associeert het ermee terwijl de Runnable-interface wordt geïmplementeerd; meerdere threads delen hetzelfde object
• De Thread-klasse biedt verschillende ingebouwde methoden zoals getPriority(), isAlive en nog veel meer, terwijl de Runnable-interface één enkele methode biedt, namelijk run().

12) Wat betekent de methode join()?

De methode join() wacht tot een thread doodgaat. Met andere woorden, het zorgt ervoor dat de lopende threads stoppen met uitvoeren totdat de thread waarmee ze samenwerken zijn taak heeft voltooid. De join-methode wordt op de volgende manieren overbelast in de Thread-klasse.

• public void join() gooit InterruptedException
• public void join (lange milliseconden) gooit InterruptedException

13) Beschrijf het doel en de werking van de sleep()-methode.

De methode sleep() in Java wordt gebruikt om een ​​thread voor een bepaalde tijd te blokkeren, wat betekent dat de uitvoering van een thread voor een bepaalde tijd wordt gepauzeerd. Er zijn twee methoden om dit te doen.

Syntaxis:

vba

• openbare statische lege slaap (lange milliseconden) gooit InterruptedException
• openbare statische lege slaap (lange milliseconden, int nanos) gooit InterruptedException

Werking van de slaap() methode

Wanneer we de methode sleep() aanroepen, pauzeert deze de uitvoering van de huidige thread voor de opgegeven tijd en geeft prioriteit aan een andere thread (indien beschikbaar). Bovendien, wanneer de wachttijd is voltooid, verandert de vorige thread opnieuw van status van wachtend naar uitvoerbaar en komt in de actieve status, en het hele proces werkt zo door totdat de uitvoering niet is voltooid.

14) Wat is het verschil tussen de methode wait() en sleep()?

15) Is het mogelijk om een ​​topic twee keer te starten?

Nee, we kunnen de thread niet opnieuw starten, want zodra een thread is gestart en uitgevoerd, gaat deze naar de status Dead. Als we daarom twee keer proberen een thread te starten, zal deze een runtimeException 'java.lang.IllegalThreadStateException' opleveren. Beschouw het volgende voorbeeld.

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

Uitvoer

 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) Kunnen we de methode run() aanroepen in plaats van start()?

Ja, het rechtstreeks aanroepen van de methode run() is geldig, maar het werkt niet als een thread, maar als een normaal object. Er zal geen sprake zijn van contextwisseling tussen de threads. Wanneer we de methode start() aanroepen, roept deze intern de methode run() aan, die een nieuwe stapel voor een thread creëert, terwijl het direct aanroepen van run() geen nieuwe stapel zal creëren.

verborgen apps

17) Hoe zit het met de daemon-threads?

De daemon-threads zijn de threads met lage prioriteit die achtergrondondersteuning en -services bieden aan de gebruikersthreads. De Daemon-thread wordt automatisch beëindigd door de JVM als het programma alleen bij de daemon-thread blijft en alle andere gebruikersthreads worden beëindigd/gestorven. Er zijn twee methoden voor daemonthread beschikbaar in de Thread-klasse:

public void setDaemon(booleaanse status):Het markeerde vroeger de thread-daemon-thread of een gebruikersthread.publieke boolean isDaemon():Het controleert of de thread een daemon is of niet.

18)Kunnen we de gebruikersthread als daemonthread maken als de thread is gestart?

Nee, als u dit doet, wordt IllegalThreadStateException gegenereerd. Daarom kunnen we alleen een daemonthread maken voordat de thread wordt gestart.

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

Uitvoer

 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)Wat is een shutdown-hook?

De shutdown hook is een thread die impliciet wordt aangeroepen voordat JVM wordt afgesloten. We kunnen het dus gebruiken om de bron op te schonen of de status op te slaan wanneer JVM normaal of abrupt wordt afgesloten. We kunnen een shutdown hook toevoegen met behulp van de volgende methode:

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

Enkele belangrijke punten over shutdown hooks zijn:

• Shutdown hooks zijn geïnitialiseerd, maar kunnen alleen worden gestart wanneer JVM wordt afgesloten.
• Shutdown hooks zijn betrouwbaarder dan de finalizer() omdat er veel minder kansen zijn dat shutdown hooks niet werken.
• De shutdown hook kan worden gestopt door de methode halt(int) van de klasse Runtime aan te roepen.

20)Wanneer moeten we een thread onderbreken?

We moeten een thread onderbreken als we de slaap- of wachtstatus van een thread willen doorbreken. We kunnen een thread onderbreken door de interrupt() aan te roepen en de InterruptedException te genereren.

21) Wat is de synchronisatie?

Synchronisatie is de mogelijkheid om de toegang van meerdere threads tot elke gedeelde bron te controleren. Het is gebruikt:

1. Om schroefdraadinterferentie te voorkomen.
2. Om consistentieproblemen te voorkomen.

Wanneer meerdere threads dezelfde taak proberen uit te voeren, bestaat de mogelijkheid van een foutief resultaat. Om dit probleem op te lossen gebruikt Java het synchronisatieproces, waardoor slechts één thread tegelijk kan worden uitgevoerd. Synchronisatie kan op drie manieren worden bereikt:

• volgens de gesynchroniseerde methode
• door gesynchroniseerd blok
• door statische synchronisatie

Syntaxis voor gesynchroniseerd blok

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

22) Wat is het doel van het gesynchroniseerde blok?

Het gesynchroniseerde blok kan worden gebruikt om synchronisatie uit te voeren op elke specifieke bron van de methode. Er kan slechts één thread tegelijk worden uitgevoerd op een bepaalde bron, en alle andere threads die proberen het gesynchroniseerde blok binnen te dringen, worden geblokkeerd.

• Gesynchroniseerd blok wordt gebruikt om een ​​object voor een gedeelde bron te vergrendelen.
• De reikwijdte van het gesynchroniseerde blok is beperkt tot het blok waarop het wordt toegepast. De reikwijdte ervan is kleiner dan die van een methode.

23)Kan een Java-object worden vergrendeld voor exclusief gebruik door een bepaalde thread?

Ja. Je kunt een object vergrendelen door het in een 'gesynchroniseerd' blok te plaatsen. Het vergrendelde object is niet toegankelijk voor andere threads dan degene die het expliciet heeft geclaimd.

24) Wat is statische synchronisatie?

Als u een statische methode gesynchroniseerd maakt, wordt de vergrendeling op de klasse geplaatst en niet op het object. Als we het gesynchroniseerde sleutelwoord vóór een methode gebruiken, wordt het object vergrendeld (één thread kan tegelijkertijd toegang krijgen tot een object), maar als we statisch gesynchroniseerd gebruiken, wordt een klasse vergrendeld (één thread kan tegelijkertijd toegang krijgen tot een klasse). Meer details.

25)Wat is het verschil tussen kennisgeving() en kennisgevingAll()?

De notificatie() wordt gebruikt om één wachtende thread te deblokkeren, terwijl de notificatieAll()-methode wordt gebruikt om alle threads in de wachtstatus te deblokkeren.

26) Wat is de impasse?

Deadlock is een situatie waarin elke thread wacht op een bron die wordt vastgehouden door een andere wachtende thread. In deze situatie wordt geen van de threads uitgevoerd, noch krijgt deze de kans om te worden uitgevoerd. In plaats daarvan bestaat er een universele wachttoestand tussen alle threads. Deadlock is een zeer gecompliceerde situatie die onze code tijdens runtime kan breken.

27) Hoe kan ik een impasse detecteren? Hoe kan het worden vermeden?

We kunnen de deadlock-conditie detecteren door de code op cmd uit te voeren en de Thread Dump te verzamelen. Als er een deadlock in de code aanwezig is, verschijnt er een bericht op cmd.

Manieren om de impasse in Java te vermijden:

Vermijd genest slot:Geneste vergrendeling is de meest voorkomende reden voor impasse, aangezien een impasse optreedt wanneer we vergrendelingen voor verschillende threads bieden, dus we moeten op een bepaald moment slechts één vergrendeling aan één thread geven.Vermijd onnodige sloten:we moeten de sloten vermijden die niet nodig zijn.Thread-join gebruiken:Thread join helpt bij het wachten op een thread totdat een andere thread de uitvoering ervan niet voltooit, zodat we een impasse kunnen voorkomen door maximaal gebruik te maken van de join-methode.

28) Wat is Thread Scheduler in Java?

Wanneer we in Java de threads maken, worden ze gecontroleerd met behulp van een Thread Scheduler, een onderdeel van JVM. Threadplanner is alleen verantwoordelijk voor het beslissen welke thread moet worden uitgevoerd. Thread Scheduler gebruikt twee mechanismen voor het plannen van de threads: Preemptive en Time Slicing.

arrays java

• Het selecteert de prioriteit van de thread.
• Het bepaalt de wachttijd voor een thread
• Het controleert de aard van de draad

29) Heeft elke thread zijn eigen stack bij multithreaded programmeren?

Ja, bij multithreaded programmeren behoudt elke thread zijn eigen of aparte stapelgebied in het geheugen, waardoor elke thread onafhankelijk van elkaar is.

30) Hoe wordt de veiligheid van een draad bereikt?

Als een methode- of klasseobject door meerdere threads tegelijk kan worden gebruikt zonder enige racevoorwaarde, dan is de klasse thread-safe. Thread safety wordt gebruikt om een ​​programma veilig te maken voor gebruik bij multithreaded programmeren. Dit kan op de volgende manieren worden bereikt:

• Synchronisatie
• Vluchtig zoekwoord gebruiken
• Met behulp van een op slot gebaseerd mechanisme
• Gebruik van atomaire wrapper-klassen

31) Wat is rasconditie?

Een Race condition is een probleem dat optreedt bij multithreaded programmeren wanneer verschillende threads tegelijkertijd worden uitgevoerd en tegelijkertijd toegang krijgen tot een gedeelde bron. Het juiste gebruik van synchronisatie kan de Race-conditie vermijden.

32) Wat is het vluchtige zoekwoord in Java?

Het vluchtige trefwoord wordt gebruikt bij multithreaded programmeren om de threadveiligheid te bereiken, omdat een verandering in één vluchtige variabele zichtbaar is voor alle andere threads, zodat één variabele door één thread tegelijk kan worden gebruikt.

33) Wat versta je onder threadpool?

• De Java Thread-pool vertegenwoordigt een groep werkthreads, die wachten op de toewijzing van de taak.
• Threads in de threadpool staan ​​onder toezicht van de serviceprovider, die één thread uit de pool haalt en er een taak aan toewijst.
• Na voltooiing van de gegeven taak kwam thread opnieuw naar de threadpool.
• De grootte van de threadpool is afhankelijk van het totale aantal threads dat in reserve wordt gehouden voor uitvoering.

De voordelen van de draadpool zijn:

• Met behulp van een threadpool kunnen de prestaties worden verbeterd.
• Met behulp van een threadpool kan een betere systeemstabiliteit optreden.

Concurrency-interviewvragen

34) Wat zijn de belangrijkste componenten van de concurrency-API?

Concurrency API kan worden ontwikkeld met behulp van de klasse en interfaces van het java.util.Concurrent-pakket. Het pakket java.util.Concurrent bevat de volgende klassen en interfaces.

• Uitvoerder
• FarkWord lid van het zwembad
• ExecuteurService
• ScheduledExecutorService
• Toekomst
• Tijdeenheid(Enum)
• CountDownLatch
• Cyclische barrière
• Semafoor
• DraadFactory
• Blokkeerwachtrij
• Vertragingswachtrij
• Sloten
• Phaser

35) Wat is de Executor-interface in Concurrency API in Java?

De Executor Interface die wordt geleverd door het pakket java.util.concurrent is de eenvoudige interface die wordt gebruikt om de nieuwe taak uit te voeren. De execute()-methode van de Executor-interface wordt gebruikt om een ​​bepaalde opdracht uit te voeren. De syntaxis van de methode execute() wordt hieronder gegeven.

void execute (uitvoerbare opdracht)

Beschouw het volgende voorbeeld:

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

Uitvoer

 Running Thread! Thread Completed 

36) Wat is BlockingQueue?

De java.util.concurrent.BlockingQueue is de subinterface van Queue die bewerkingen ondersteunt, zoals wachten op de beschikbaarheid van ruimte voordat een nieuwe waarde wordt ingevoegd of wachten tot de wachtrij niet leeg is voordat er een element uit wordt opgehaald. Beschouw het volgende voorbeeld.

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

Uitvoer

microservices-tutorial

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

37) Hoe implementeer ik het producent-consumentprobleem met behulp van BlockingQueue?

Het producent-consumentprobleem kan op de volgende manier worden opgelost door BlockingQueue te gebruiken.

 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) Wat is het verschil tussen de Java Callable-interface en de Runnable-interface?

De Callable-interface en Runnable-interface worden beide gebruikt door de klassen die met meerdere threads wilden uitvoeren. Er zijn echter twee belangrijke verschillen tussen beide:

• Een Callable-interface kan een resultaat retourneren, terwijl de Runnable-interface geen enkel resultaat kan retourneren.
• Een opvraagbare interface kan een gecontroleerde uitzondering genereren, terwijl de uitvoerbare interface geen gecontroleerde uitzondering kan genereren.
• Een Callable-interface kan niet worden gebruikt vóór Java 5, terwijl de Runnable-interface wel kan worden gebruikt.

39) Wat is de atomaire actie in gelijktijdigheid op Java?

• De atomaire actie is de operatie die kan worden uitgevoerd in een enkele eenheid van een taak zonder enige tussenkomst van de andere operaties.
• De Atomic-actie kan niet tussen de taken worden gestopt. Eenmaal gestart, stopt het vullen pas na voltooiing van de taak.
• Een incrementele bewerking zoals a++ staat geen atomaire actie toe.
• Alle lees- en schrijfbewerkingen voor de primitieve variabele (behalve lang en dubbel) zijn atomaire bewerkingen.
• Alle lees- en schrijfbewerkingen voor de vluchtige variabele (inclusief long en double) zijn atomaire bewerkingen.
• De Atomic-methoden zijn beschikbaar in het pakket java.util.Concurrent.

40) Wat is de vergrendelingsinterface in de Concurrency API in Java?

De java.util.concurrent.locks.Lock-interface wordt gebruikt als synchronisatiemechanisme. Het werkt vergelijkbaar met het gesynchroniseerde blok. Er zijn een paar verschillen tussen het slot en het gesynchroniseerde blok, die hieronder worden weergegeven.

• De vergrendelingsinterface biedt de garantie voor de volgorde waarin de wachtende thread toegang krijgt, terwijl het gesynchroniseerde blok dit niet garandeert.
• De vergrendelingsinterface biedt de optie voor een time-out als de vergrendeling niet wordt verleend, terwijl het gesynchroniseerde blok dat niet biedt.
• De methoden van de Lock-interface, dat wil zeggen Lock() en Unlock(), kunnen op verschillende manieren worden aangeroepen, terwijl een enkel gesynchroniseerd blok volledig in één enkele methode moet zijn opgenomen.

41) Leg de ExecutorService-interface uit.

De ExecutorService Interface is de subinterface van de Executor-interface en voegt de functies toe om de levenscyclus te beheren. Beschouw het volgende voorbeeld.

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

Uitvoer

 Shutdown executor shutdown finished 

42) Wat is het verschil tussen synchrone programmering en asynchrone programmering met betrekking tot een thread?

Synchrone programmering: In het synchrone programmeermodel wordt een thread toegewezen om een ​​taak te voltooien en daarom is de thread eraan gaan werken, en deze is pas beschikbaar voor andere taken zodra de toegewezen taak is beëindigd.

Asynchrone programmering: Bij asynchrone programmering kan één taak door meerdere threads worden voltooid, waardoor de verschillende threads maximaal kunnen worden gebruikt.

43) Wat versta je onder Callable en Future in Java?

Java Oproepbare interface: In Java5 werd de opvraagbare interface geleverd door het pakket java.util.concurrent. Het is vergelijkbaar met de Runnable-interface, maar kan een resultaat retourneren en een uitzondering genereren. Het biedt ook een run()-methode voor het uitvoeren van een thread. Java Callable kan elk object retourneren omdat het Generic gebruikt.

Syntaxis:

openbare interface Oproepbaar

Java Future-interface: De Java Future-interface geeft het resultaat van een gelijktijdig proces. De Callable-interface retourneert het object java.util.concurrent.Future.

Java Future biedt de volgende implementatiemethoden.

cancel(boolean�mayInterruptIfRunning):Het wordt gebruikt om de uitvoering van de toegewezen taak te annuleren.krijgen():Het wacht op de tijd dat de uitvoering niet is voltooid en haalt vervolgens het resultaat op.gaat niet door():Het retourneert de Booleaanse waarde zoals het waar retourneert als de taak vóór voltooiing is geannuleerd.is klaar():Het retourneert waar als de taak met succes is voltooid, anders wordt onwaar geretourneerd.

44. Wat is het verschil tussen de ScheduledExecutorService- en ExecutorService-interface?

ExecutorServcie en ScheduledExecutorService zijn beide de interfaces van het java.util.Concurrent-pakket, maar ScheduledExecutorService biedt enkele aanvullende methoden om de Runnable en Callable-taken uit te voeren met de vertraging of elke vaste tijdsperiode.

45) Definieer de FutureTask-klasse in Java?

De Java FutureTask-klasse biedt een basisimplementatie van de Future-interface. Het resultaat kan alleen worden verkregen als de uitvoering van één taak is voltooid, en als de berekening niet is voltooid, wordt de get-methode geblokkeerd. Als de uitvoering is voltooid, kan deze niet opnieuw worden gestart en kan deze ook niet worden geannuleerd.

Syntaxis

public class FutureTask breidt Object-implementaties RunnableFuture uit