Multithreading und Synchronisation gelten als die typischen Kapitel der Java-Programmierung. In Spieleentwicklungsunternehmen werden in Vorstellungsgesprächen am häufigsten Fragen zum Thema Multithreading gestellt. Nachfolgend finden Sie eine Liste häufig gestellter Fragen zu Java-Multithreading und Parallelitätsinterviews.
Fragen zum Multithreading-Interview
1) Was ist Multithreading?
Multithreading ist ein Prozess, bei dem mehrere Threads gleichzeitig ausgeführt werden. Um das Multitasking zu erreichen, wird Multithreading verwendet. Es verbraucht weniger Speicher und bietet eine schnelle und effiziente Leistung. Seine Hauptvorteile sind:
- Threads teilen sich denselben Adressraum.
- Der Faden ist leicht.
- Der Aufwand für die Kommunikation zwischen den Prozessen ist gering.
2) Was ist der Thread?
Ein Thread ist ein leichter Unterprozess. Es handelt sich um einen separaten Ausführungspfad, da jeder Thread in einem anderen Stapelrahmen ausgeführt wird. Ein Prozess kann mehrere Threads enthalten. Threads teilen sich die Prozessressourcen, werden aber dennoch unabhängig voneinander ausgeführt.
Mehr Details.3) Zwischen Prozess und Thread unterscheiden?
Es gibt die folgenden Unterschiede zwischen Prozess und Thread.
- Ein Programm in der Ausführung wird als Prozess bezeichnet, während; Ein Thread ist eine Teilmenge des Prozesses
- Prozesse sind unabhängig, während Threads die Teilmenge von Prozessen sind.
- Prozesse haben unterschiedliche Adressräume im Speicher, während Threads einen gemeinsam genutzten Adressraum enthalten.
- Der Kontextwechsel zwischen den Threads ist im Vergleich zu Prozessen schneller.
- Die Kommunikation zwischen Prozessen ist langsamer und teurer als die Kommunikation zwischen Threads.
- Jede Änderung im übergeordneten Prozess wirkt sich nicht auf den untergeordneten Prozess aus, wohingegen Änderungen im übergeordneten Thread Auswirkungen auf den untergeordneten Thread haben können.
4) Was verstehen Sie unter Inter-Thread-Kommunikation?
- Der Kommunikationsprozess zwischen synchronisierten Threads wird als Inter-Thread-Kommunikation bezeichnet.
- Die Kommunikation zwischen Threads wird verwendet, um Thread-Polling in Java zu vermeiden.
- Die Ausführung des Threads in seinem kritischen Abschnitt wird angehalten, und ein anderer Thread darf zur Ausführung in denselben kritischen Abschnitt eintreten (oder ihn sperren).
- Es kann mit den Methoden wait(), notify() und notifyAll() abgerufen werden.
5) Was ist der Zweck der Methode wait() in Java?
Die Methode wait() wird von der Object-Klasse in Java bereitgestellt. Diese Methode wird für die Inter-Thread-Kommunikation in Java verwendet. Mit java.lang.Object.wait() wird der aktuelle Thread angehalten und gewartet, bis ein anderer Thread die Methode notify() oder notifyAll() aufruft. Die Syntax ist unten angegeben.
public final void wait()
6) Warum muss die Methode wait() vom synchronisierten Block aufgerufen werden?
Wir müssen die Wartemethode aufrufen, sonst wird sie ausgelöst java.lang.IllegalMonitorStateException Ausnahme. Darüber hinaus benötigen wir die Methode wait() für die Kommunikation zwischen Threads mit notify() und notifyAll(). Daher muss es für die ordnungsgemäße und korrekte Kommunikation im synchronisierten Block vorhanden sein.
7) Was sind die Vorteile von Multithreading?
Die Multithreading-Programmierung bietet folgende Vorteile:
- Durch Multithreading kann eine Anwendung/ein Programm immer auf Eingaben reagieren, auch wenn sie bereits mit einigen Hintergrundaufgaben ausgeführt werden
- Multithreading ermöglicht die schnellere Ausführung von Aufgaben, da Threads unabhängig voneinander ausgeführt werden.
- Multithreading sorgt für eine bessere Nutzung des Cache-Speichers, da Threads die gemeinsamen Speicherressourcen gemeinsam nutzen.
- Multithreading reduziert die Anzahl der erforderlichen Server, da ein Server mehrere Threads gleichzeitig ausführen kann.
8) Welche Zustände gibt es im Lebenszyklus eines Threads?
Ein Thread kann während seiner Lebensdauer einen der folgenden Zustände haben:
9) Was ist der Unterschied zwischen präventiver Planung und Zeitscheiben?
Bei der präventiven Planung wird die Aufgabe mit der höchsten Priorität ausgeführt, bis sie in den Warte- oder Totzustand übergeht oder eine Aufgabe mit höherer Priorität ins Leben gerufen wird. Beim Zeitscheibenverfahren wird eine Aufgabe für einen vordefinierten Zeitraum ausgeführt und dann wieder in den Pool bereiter Aufgaben aufgenommen. Der Planer bestimmt dann anhand der Priorität und anderer Faktoren, welche Aufgabe als nächstes ausgeführt werden soll.
10) Was ist Kontextwechsel?
Beim Kontextwechsel wird der Status des Prozesses (oder Threads) gespeichert, sodass er wiederhergestellt und die Ausführung später am selben Punkt fortgesetzt werden kann. Durch den Kontextwechsel können mehrere Prozesse dieselbe CPU gemeinsam nutzen.
11) Unterscheiden Sie zwischen der Thread-Klasse und der Runnable-Schnittstelle zum Erstellen eines Threads?
Der Thread kann auf zwei Arten erstellt werden.
- Durch Erweiterung der Thread-Klasse
- Durch die Implementierung der Runnable-Schnittstelle
Die Hauptunterschiede zwischen beiden Methoden sind jedoch nachstehend aufgeführt:
- Durch die Erweiterung der Thread-Klasse können wir keine andere Klasse erweitern, da Java bei der Implementierung der Runnable-Schnittstelle keine Mehrfachvererbung zulässt; Wir können auch andere Basisklassen erweitern (falls erforderlich).
- Durch die Erweiterung der Thread-Klasse erstellt jeder Thread das eindeutige Objekt und verknüpft es mit ihm, während die Runnable-Schnittstelle implementiert wird. Mehrere Threads teilen sich dasselbe Objekt
- Die Thread-Klasse bietet verschiedene integrierte Methoden wie getPriority(), isAlive und viele mehr, während die Runnable-Schnittstelle eine einzige Methode bereitstellt, nämlich run().
12) Was ist die Methode join()?
Die Methode join() wartet darauf, dass ein Thread stirbt. Mit anderen Worten: Es führt dazu, dass die aktuell ausgeführten Threads nicht mehr ausgeführt werden, bis der Thread, dem er beitritt, seine Aufgabe abgeschlossen hat. Die Join-Methode wird in der Thread-Klasse auf folgende Weise überladen.
- public void join() löst eine InterruptedException aus
- public void join (lange Millisekunden) löst eine InterruptedException aus
13) Beschreiben Sie den Zweck und die Funktionsweise der Methode „sleep()“.
Die Methode „sleep()“ in Java wird verwendet, um einen Thread für eine bestimmte Zeit zu blockieren, was bedeutet, dass die Ausführung eines Threads für eine bestimmte Zeit angehalten wird. Dafür gibt es zwei Methoden.
Syntax:
Latexmatrix
- öffentlicher statischer Leerschlaf (lange Millisekunden) löst eine InterruptedException aus
- public static void sleep (lange Millisekunden, int Nanos) löst eine InterruptedException aus
Funktionsweise der Methode „sleep()“.
Wenn wir die Methode „sleep()“ aufrufen, unterbricht sie die Ausführung des aktuellen Threads für die angegebene Zeit und gibt einem anderen Thread (falls verfügbar) Priorität. Wenn außerdem die Wartezeit abgelaufen ist, ändert der vorherige Thread erneut seinen Status von „Warten“ in „Ausführbar“ und wechselt in den Status „Laufen“, und der gesamte Prozess läuft so weiter, bis die Ausführung nicht abgeschlossen ist.
14) Was ist der Unterschied zwischen der Methode „wait()“ und „sleep()“?
| Warten() | schlafen() |
|---|---|
| 1) Die Methode wait() ist in der Klasse Object definiert. | Die Methode sleep() ist in der Thread-Klasse definiert. |
| 2) Die Methode wait() gibt die Sperre frei. | Die Methode „sleep()“ gibt die Sperre nicht frei. |
15) Ist es möglich, einen Thread zweimal zu starten?
Nein, wir können den Thread nicht neu starten, da ein Thread, sobald er gestartet und ausgeführt wurde, in den Dead-Zustand übergeht. Wenn wir also zweimal versuchen, einen Thread zu starten, wird eine runtimeException „java.lang.IllegalThreadStateException“ ausgegeben. Betrachten Sie das folgende Beispiel.
in.next Java
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(); } } Ausgabe
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)Mehr Details.
16) Können wir die run()-Methode anstelle von start() aufrufen?
Ja, der direkte Aufruf der run()-Methode ist gültig, aber sie funktioniert nicht als Thread, sondern als normales Objekt. Es findet kein Kontextwechsel zwischen den Threads statt. Wenn wir die start()-Methode aufrufen, ruft sie intern die run()-Methode auf, die einen neuen Stapel für einen Thread erstellt, während ein direkter Aufruf von run() keinen neuen Stapel erstellt.
Mehr Details.17) Was ist mit den Daemon-Threads?
Die Daemon-Threads sind Threads mit niedriger Priorität, die den Benutzer-Threads Hintergrundunterstützung und -dienste bereitstellen. Der Daemon-Thread wird von der JVM automatisch beendet, wenn das Programm nur beim Daemon-Thread verbleibt und alle anderen Benutzer-Threads beendet/abgestorben sind. In der Thread-Klasse stehen zwei Methoden für Daemon-Threads zur Verfügung:
18)Können wir den Benutzer-Thread als Daemon-Thread machen, wenn der Thread gestartet ist?
Nein, wenn Sie dies tun, wird eine IllegalThreadStateException ausgelöst. Daher können wir nur einen Daemon-Thread erstellen, bevor wir den Thread starten.
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. } } Ausgabe
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)Mehr Details.
19)Was ist ein Shutdown-Hook?
Der Shutdown-Hook ist ein Thread, der implizit aufgerufen wird, bevor die JVM heruntergefahren wird. So können wir damit die Ressource bereinigen oder den Status speichern, wenn die JVM normal oder abrupt heruntergefahren wird. Wir können einen Shutdown-Hook hinzufügen, indem wir die folgende Methode verwenden:
public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); Einige wichtige Punkte zu Shutdown-Hooks sind:
- Shutdown-Hooks wurden initialisiert, können aber erst gestartet werden, wenn die JVM heruntergefahren wurde.
- Shutdown-Hooks sind zuverlässiger als finalizer(), da die Wahrscheinlichkeit, dass Shutdown-Hooks nicht ausgeführt werden, sehr gering ist.
- Der Shutdown-Hook kann durch Aufrufen der Methode halt(int) der Runtime-Klasse gestoppt werden.
20)Wann sollten wir einen Thread unterbrechen?
Wir sollten einen Thread unterbrechen, wenn wir den Ruhe- oder Wartezustand eines Threads beenden möchten. Wir können einen Thread unterbrechen, indem wir interrupt() aufrufen und die InterruptedException auslösen.
Mehr Details.21) Was ist die Synchronisation?
Unter Synchronisierung versteht man die Möglichkeit, den Zugriff mehrerer Threads auf eine beliebige gemeinsam genutzte Ressource zu steuern. Es ist benutzt:
- Um Fadeninterferenzen zu vermeiden.
- Um Konsistenzprobleme zu vermeiden.
Wenn mehrere Threads versuchen, dieselbe Aufgabe auszuführen, besteht die Möglichkeit eines fehlerhaften Ergebnisses. Um dieses Problem zu beheben, verwendet Java daher den Synchronisierungsprozess, der es ermöglicht, jeweils nur einen Thread auszuführen. Die Synchronisierung kann auf drei Arten erreicht werden:
- durch die synchronisierte Methode
- durch synchronisierten Block
- durch statische Synchronisation
Syntax für synchronisierten Block
synchronized(object reference expression) { //code block } Mehr Details.22) Was ist der Zweck des Synchronized-Blocks?
Der Synchronized-Block kann verwendet werden, um eine Synchronisierung für eine bestimmte Ressource der Methode durchzuführen. Es kann jeweils nur ein Thread auf einer bestimmten Ressource ausgeführt werden, und alle anderen Threads, die versuchen, in den synchronisierten Block einzutreten, werden blockiert.
- Der synchronisierte Block wird verwendet, um ein Objekt für eine beliebige gemeinsam genutzte Ressource zu sperren.
- Der Umfang des synchronisierten Blocks ist auf den Block beschränkt, auf den er angewendet wird. Sein Umfang ist kleiner als der einer Methode.
23)Kann ein Java-Objekt für die ausschließliche Verwendung durch einen bestimmten Thread gesperrt werden?
Ja. Sie können ein Objekt sperren, indem Sie es in einen „synchronisierten“ Block einfügen. Auf das gesperrte Objekt kann kein anderer Thread zugreifen als derjenige, der es explizit beansprucht hat.
24) Was ist statische Synchronisierung?
Wenn Sie eine statische Methode als synchronisiert festlegen, gilt die Sperre für die Klasse und nicht für das Objekt. Wenn wir das Schlüsselwort „synced“ vor einer Methode verwenden, wird das Objekt gesperrt (jeweils ein Thread kann auf ein Objekt zugreifen), wenn wir jedoch das Schlüsselwort „static synchronisiert“ verwenden, wird eine Klasse gesperrt (jeweils ein Thread kann auf eine Klasse zugreifen). Mehr Details.
25)Was ist der Unterschied zwischen notify() und notifyAll()?
Die Methode notify() wird verwendet, um einen wartenden Thread zu entsperren, während die Methode notifyAll() verwendet wird, um alle Threads im Wartezustand zu entsperren.
26)Was ist der Deadlock?
Deadlock ist eine Situation, in der jeder Thread auf eine Ressource wartet, die von einem anderen wartenden Thread gehalten wird. In dieser Situation wird weder der Thread ausgeführt, noch erhält er die Chance, ausgeführt zu werden. Stattdessen gibt es einen universellen Wartezustand zwischen allen Threads. Deadlock ist eine sehr komplizierte Situation, die unseren Code zur Laufzeit beschädigen kann.
Mehr Details.27) Wie erkennt man einen Deadlock-Zustand? Wie kann es vermieden werden?
Wir können den Deadlock-Zustand erkennen, indem wir den Code auf cmd ausführen und den Thread-Dump sammeln. Wenn im Code ein Deadlock vorhanden ist, wird auf cmd eine Meldung angezeigt.
Möglichkeiten, den Deadlock-Zustand in Java zu vermeiden:
28) Was ist Thread Scheduler in Java?
Wenn wir in Java die Threads erstellen, werden sie mit Hilfe eines Thread-Schedulers überwacht, der Teil der JVM ist. Der Thread-Scheduler ist nur für die Entscheidung verantwortlich, welcher Thread ausgeführt werden soll. Der Thread-Scheduler verwendet zwei Mechanismen zum Planen der Threads: Preemptive und Time Slicing.
Der Java-Thread-Scheduler funktioniert auch, um Folgendes für einen Thread zu entscheiden:- Es wählt die Priorität des Threads aus.
- Es bestimmt die Wartezeit für einen Thread
- Es überprüft die Art des Threads
29) Hat jeder Thread seinen Stapel in der Multithread-Programmierung?
Ja, bei der Multithread-Programmierung verwaltet jeder Thread seinen eigenen oder separaten Stapelbereich im Speicher, wodurch jeder Thread unabhängig voneinander ist.
30) Wie wird die Sicherheit eines Threads erreicht?
Wenn eine Methode oder ein Klassenobjekt von mehreren Threads gleichzeitig ohne Racebedingung verwendet werden kann, ist die Klasse threadsicher. Thread-Sicherheit wird verwendet, um die Verwendung eines Programms in der Multithread-Programmierung sicher zu machen. Dies kann auf folgende Weise erreicht werden:
- Synchronisation
- Verwenden des Schlüsselworts „Volatile“.
- Verwendung eines sperrbasierten Mechanismus
- Verwendung von atomaren Wrapper-Klassen
31) Was ist eine Rennbedingung?
Eine Race-Bedingung ist ein Problem, das bei der Multithread-Programmierung auftritt, wenn verschiedene Threads gleichzeitig ausgeführt werden und gleichzeitig auf eine gemeinsam genutzte Ressource zugreifen. Durch die ordnungsgemäße Verwendung der Synchronisierung kann die Race-Bedingung vermieden werden.
32) Was ist das Schlüsselwort volatile in Java?
Das Schlüsselwort „Volatile“ wird in der Multithread-Programmierung verwendet, um Thread-Sicherheit zu gewährleisten, da eine Änderung in einer flüchtigen Variablen für alle anderen Threads sichtbar ist, sodass jeweils eine Variable von einem Thread verwendet werden kann.
33) Was versteht man unter Thread-Pool?
- Der Java-Thread-Pool stellt eine Gruppe von Arbeitsthreads dar, die auf die Zuweisung der Aufgabe warten.
- Threads im Thread-Pool werden vom Dienstanbieter überwacht, der einen Thread aus dem Pool zieht und ihm einen Job zuweist.
- Nach Abschluss der angegebenen Aufgabe gelangte der Thread erneut zum Thread-Pool.
- Die Größe des Thread-Pools hängt von der Gesamtzahl der Threads ab, die für die Ausführung in Reserve gehalten werden.
Die Vorteile des Thread-Pools sind:
Alphabet als Zahlen
- Mithilfe eines Thread-Pools kann die Leistung verbessert werden.
- Durch die Verwendung eines Thread-Pools kann eine bessere Systemstabilität erzielt werden.
Fragen zum Parallelitätsinterview
34) Was sind die Hauptkomponenten der Parallelitäts-API?
Die Parallelitäts-API kann mithilfe der Klasse und Schnittstellen des Pakets java.util.Concurrent entwickelt werden. Das Paket java.util.Concurrent enthält die folgenden Klassen und Schnittstellen.
- Testamentsvollstrecker
- FarkJoinPool
- ExecutorService
- ScheduledExecutorService
- Zukunft
- TimeUnit(Enum)
- CountDownLatch
- CyclicBarrier
- Semaphor
- ThreadFactory
- BlockingQueue
- Verzögerungswarteschlange
- Schlösser
- Phaser
35) Was ist die Executor-Schnittstelle in der Concurrency API in Java?
Die vom Paket java.util.concurrent bereitgestellte Executor-Schnittstelle ist die einfache Schnittstelle, die zum Ausführen der neuen Aufgabe verwendet wird. Die Methodeexecute() der Executor-Schnittstelle wird verwendet, um einen bestimmten Befehl auszuführen. Die Syntax der Methodeexecute() ist unten angegeben.
voidexecute(Ausführbarer Befehl)
Betrachten Sie das folgende Beispiel:
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(); } } } } Ausgabe
Running Thread! Thread Completed
36) Was ist BlockingQueue?
Die java.util.concurrent.BlockingQueue ist die Subschnittstelle von Queue, die Vorgänge wie das Warten auf die Verfügbarkeit von Speicherplatz vor dem Einfügen eines neuen Werts oder das Warten darauf, dass die Warteschlange nicht leer wird, bevor ein Element daraus abgerufen wird, unterstützt. Betrachten Sie das folgende Beispiel.
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(); } } } } Ausgabe
Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5
37) Wie implementiert man das Producer-Consumer-Problem mithilfe von BlockingQueue?
Das Producer-Consumer-Problem kann durch die Verwendung von BlockingQueue auf folgende Weise gelöst werden.
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't guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn'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('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(); } } } } </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�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't be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;> 38) Was ist der Unterschied zwischen der Java Callable-Schnittstelle und der Runnable-Schnittstelle?
Die Callable-Schnittstelle und die Runnable-Schnittstelle werden beide von den Klassen verwendet, die mit mehreren Threads ausgeführt werden möchten. Es gibt jedoch zwei Hauptunterschiede zwischen den beiden:
- Eine Callable-Schnittstelle kann ein Ergebnis zurückgeben, wohingegen die Runnable-Schnittstelle kein Ergebnis zurückgeben kann.
- Eine Callable-Schnittstelle kann eine geprüfte Ausnahme auslösen, wohingegen die Runnable-Schnittstelle keine geprüfte Ausnahme auslösen kann.
- Eine Callable-Schnittstelle kann vor Java 5 nicht verwendet werden, wohingegen die Runnable-Schnittstelle verwendet werden kann.
39) Was ist die atomare Aktion in Parallelität in Java?
- Die atomare Aktion ist die Operation, die in einer einzelnen Einheit einer Aufgabe ohne Beeinträchtigung der anderen Operationen ausgeführt werden kann.
- Die Atomic-Aktion kann zwischen den Aufgaben nicht gestoppt werden. Nach dem Start stoppt das Füllen erst nach Abschluss der Aufgabe.
- Eine Inkrementierungsoperation wie a++ erlaubt keine atomare Aktion.
- Alle Lese- und Schreibvorgänge für die primitive Variable (außer Long und Double) sind atomare Operationen.
- Alle Lese- und Schreibvorgänge für die flüchtige Variable (einschließlich Long und Double) sind atomare Operationen.
- Die Atomic-Methoden sind im Paket java.util.Concurrent verfügbar.
40) Was ist die Sperrschnittstelle in der Concurrency API in Java?
Als Synchronisationsmechanismus wird die Schnittstelle java.util.concurrent.locks.Lock verwendet. Es funktioniert ähnlich wie der synchronisierte Block. Es gibt einige Unterschiede zwischen der Sperre und dem synchronisierten Block, die unten aufgeführt sind.
- Die Sperrschnittstelle garantiert die Reihenfolge, in der dem wartenden Thread der Zugriff gewährt wird, während der synchronisierte Block dies nicht garantiert.
- Die Sperrschnittstelle bietet die Option einer Zeitüberschreitung, wenn die Sperre nicht gewährt wird, während der synchronisierte Block dies nicht bietet.
- Die Methoden der Lock-Schnittstelle, d. h. Lock() und Unlock(), können in unterschiedlichen Methoden aufgerufen werden, wohingegen ein einzelner synchronisierter Block vollständig in einer einzigen Methode enthalten sein muss.
41) Erklären Sie die ExecutorService-Schnittstelle.
Die ExecutorService-Schnittstelle ist die Unterschnittstelle der Executor-Schnittstelle und fügt die Funktionen zur Verwaltung des Lebenszyklus hinzu. Betrachten Sie das folgende Beispiel.
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(); } } } } Ausgabe
Geschichte in Java
Shutdown executor shutdown finished
42) Was ist der Unterschied zwischen synchroner Programmierung und asynchroner Programmierung in Bezug auf einen Thread?
Synchrone Programmierung: Im synchronen Programmiermodell wird einem Thread die Aufgabe zugewiesen, eine Aufgabe abzuschließen, und der Thread beginnt daher mit der Arbeit daran. Er ist erst dann für andere Aufgaben verfügbar, wenn er die zugewiesene Aufgabe beendet.
Asynchrone Programmierung: Bei der asynchronen Programmierung kann ein Job von mehreren Threads ausgeführt werden und bietet somit maximale Benutzerfreundlichkeit der verschiedenen Threads.
43) Was verstehen Sie unter Callable und Future in Java?
Aufrufbare Java-Schnittstelle: In Java5 wurde eine aufrufbare Schnittstelle durch das Paket java.util.concurrent bereitgestellt. Es ähnelt der Runnable-Schnittstelle, kann jedoch ein Ergebnis zurückgeben und eine Ausnahme auslösen. Es bietet auch eine run()-Methode zur Ausführung eines Threads. Java Callable kann jedes Objekt zurückgeben, da es Generic verwendet.
Syntax:
öffentliche Schnittstelle Aufrufbar
Java Future-Schnittstelle: Die Java Future-Schnittstelle liefert das Ergebnis eines gleichzeitigen Prozesses. Die Callable-Schnittstelle gibt das Objekt von java.util.concurrent.Future zurück.
Java Future bietet folgende Methoden zur Implementierung.
44. Was ist der Unterschied zwischen der ScheduledExecutorService- und der ExecutorService-Schnittstelle?
ExecutorServcie und ScheduledExecutorService sind beide die Schnittstellen des Pakets java.util.Concurrent, ScheduledExecutorService bietet jedoch einige zusätzliche Methoden, um die ausführbaren und aufrufbaren Aufgaben mit der Verzögerung oder in jedem festen Zeitraum auszuführen.
45) FutureTask-Klasse in Java definieren?
Die Java FutureTask-Klasse stellt eine Basisimplementierung der Future-Schnittstelle bereit. Das Ergebnis kann nur erhalten werden, wenn die Ausführung einer Aufgabe abgeschlossen ist. Wenn die Berechnung nicht erfolgreich ist, wird die Get-Methode blockiert. Wenn die Ausführung abgeschlossen ist, kann sie nicht erneut gestartet und nicht abgebrochen werden.
Syntax
Die öffentliche Klasse FutureTask erweitert das Objekt und implementiert RunnableFuture