Multithreading-Interviewfragen in Java

In Java umfasst Multithreading die gleichzeitige Ausführung von zwei oder mehr Threads, wodurch die Prozessgeschwindigkeit basierend auf der Systemkapazität erhöht wird. Multithreading verarbeitet die kleinsten Einheiten gleichzeitig und ermöglicht so eine schnellere Ausführung. Entwickler nutzen es für Aufgaben wie Animationen, Spiele und die Verwaltung großer Anwendungen und tragen so zur Speicherplatz- und Zeiteffizienz bei.

Wenn Sie nun nach einem Job im Zusammenhang mit Multithreading in Java suchen, müssen Sie sich auf die Multithreading-Interviewfragen in Java vorbereiten. Tatsächlich ist jedes Vorstellungsgespräch aufgrund der Stellenprofile anders. Hier haben wir die wichtigen Multithreading-Interviewfragen in Java mit ihren Antworten vorbereitet, die Ihnen bei Ihrem Interview zum Erfolg verhelfen werden.

Starten Sie Ihren kostenlosen Softwareentwicklungskurs

Webentwicklung, Programmiersprachen, Softwaretests und andere

In diesem Artikel werden die 40 wichtigsten und am häufigsten gestellten Fragen zu Multithreading-Interviewfragen in Java vorgestellt.

Q1. Erklären Sie die verschiedenen Thread-Zustände.

Antwort:
Die Zustände des Threads werden auch als Lebenszyklus eines Threads bezeichnet. Nachfolgend finden Sie die verschiedenen Status des Threads:

• • Neu: Dies bedeutet, dass sich der Thread in einem neuen Zustand befindet und vor dem Aufruf der Startmethode die Instanz der Thread-Klasse erstellen muss.
  • Ausführbar: Nach dem Aufruf der Startmethode befindet sich der Thread in einem ausführbaren Zustand und der Scheduler hat ihn nicht als laufenden Thread ausgewählt.
  • Wird ausgeführt: Wenn der Thread-Scheduler ausgewählt ist, befindet er sich im laufenden Zustand.
  • Blockiert: Es wird auch als nicht ausführbar bezeichnet. Wenn der Thread nicht ausgeführt werden kann, ist er noch aktiv.
  • Beendet: Dies ist der Zustand, wenn die Ausführungsmethode beendet wird oder sich im toten Zustand befindet.

Q2. Was ist der Thread in Java?

Antwort: Der Thread bezieht sich auf eine kleine Einheit, deren Ausführung weniger Zeit in Anspruch nimmt. Es ist im Wesentlichen unabhängig vom Ausführungspfad. Dies ist eine der Möglichkeiten, die Vorteile mehrerer in der Maschine verfügbarer CPUs zu nutzen. Mithilfe mehrerer Threads wird die Verarbeitung der CPU-Aufgabe schneller. Java wird hauptsächlich zur Unterstützung von Multithreading verwendet. Java unterstützt Multithreading, um die Vorteile mehrerer Prozessoren zu nutzen und die Programmleistung zu verbessern. Die Erweiterung der Thread-Klasse oder die Implementierung der Runnable-Schnittstelle sind zwei Möglichkeiten, Threads zu erstellen.

Q3. Erklären Sie den Unterschied zwischen Thread und Prozess in JAVA.

Antwort: Der Thread ist die kleinste Ausführungsaufgabe innerhalb des Prozesses. Der Prozess ist eine eigenständige Ausführungsumgebung mit mehr als einem Thread oder mehreren Threads. Threads sind die Unterteilung des Prozesses. Der Thread hat direkten Zugriff auf das Datensegment des Prozesses, während der Prozess über eine eigene Kopie des Datensegments verfügt. Der Thread teilt hauptsächlich die vom Prozess erstellte Adresse, und der Prozess verfügt über eine eigene Adresse.

Der Thread kann einfach erstellt werden und die Prozesserstellung erfordert viele Aufgaben. Der Thread kann problemlos mit anderen Threads kommunizieren, während der Prozess problemlos mit dem untergeordneten Prozess kommunizieren kann, die Kommunikation zwischen Prozessen jedoch schwierig ist. Der Thread verfügt über einen eigenen Stapel, während der Prozess die Speicherressourcen wie Heap-Speicher usw. gemeinsam nutzt. Wenn im Thread Änderungen vorgenommen wurden, wirkt sich dies auf alle Threads aus, im Prozess jedoch nicht auf andere Prozesse.

Q4. Erklären Sie das Java-Speichermodell.

Antwort: Dies sind die häufigsten Multithreading-Interviewfragen in Java, die in einem Interview gestellt werden. In der aktuellen IT-Branche müssen normalerweise mehrere Aufgaben von einem Multithreading-Tester übernommen werden.

Das Java-Speichermodell legt einen bestimmten Satz von Regeln fest, die Java-Programme einhalten müssen, um über verschiedene Speicherarchitekturen, CPUs und Betriebssysteme hinweg ein konsistentes Verhalten zu zeigen. Diese Regeln spielen beim Multithreading eine entscheidende Rolle. Das Java-Speichermodell hilft dabei, die in einem der Threads vorgenommenen Änderungen zu unterscheiden, und diese Änderung sollte auch für andere Threads sichtbar sein. Dieser Mod ist eine Programmreihenfolge, die besagt, dass die Aktion jedes Threads ausgeführt wird, bevor jeder Thread später in der Programmreihenfolge kommt.

F5. Erklären Sie die Verwendung flüchtiger Variablen in Java Multithreading.

Antwort: Das Schlüsselwort oder die Variable volatile stellt sicher, dass gemeinsam genutzte Variablen oder Instanzvariablen ständig aktualisiert werden, wenn mehrere Threads Änderungen vornehmen. Es handelt sich um einen speziellen Modifikator, der nur auf Instanzvariablen anwendbar ist, nicht auf Methoden. Durch die Deklaration eines Felds als flüchtig in Java wird sichergestellt, dass das Java-Speichermodell konsistente Werte für diese Variable über alle Threads hinweg garantiert. Das Programm liest den Wert der flüchtigen Variablen immer aus dem Hauptspeicher und verringert so die Wahrscheinlichkeit von Speicherkonsistenzfehlern. Darüber hinaus kann eine flüchtige Java-Variable, die eine Objektreferenz darstellt, null sein. Die Anwendung des Schlüsselworts volatile ist erforderlich, wenn eine Variable über mehrere Threads hinweg verwendet wird.

Q6. Erklären Sie die Rennbedingung in Threads.

Antwort: Die Race-Bedingung tritt auf, wenn es ein Rennen zwischen mehreren Threads gibt. Diese Race-Bedingung wird hauptsächlich durch einige Programmierfehler oder -fehler verursacht. Der Thread, der ausgeführt werden muss, hat zunächst das Rennen verloren und dann den zweiten ausgeführt, und es kam zu einer Änderung im Verhalten des Codes, die als nicht deterministische Fehler bezeichnet wird. Aufgrund der zufälligen Natur der Threads wird es zu einem der schwierigsten Fehler, ihn herauszufinden und zu reproduzieren.

F7. Erklären Sie das Fork-Join-Framework in Java.

Antwort: Das Fork-Join-Framework wird in JDK7 eingeführt. Es ist ein leistungsstarkes Tool für Java-Entwickler, um die Vorteile mehrerer Prozessoren heutiger Weltserver zu nutzen. Es ist hauptsächlich für Arbeiten konzipiert, die in kleinere Teile unterteilt werden können. Das Hauptziel besteht darin, die verfügbare Rechenleistung zu nutzen, um die Anwendungsleistung zu steigern. Es wurde hauptsächlich der Work-Stealing-Algorithmus verwendet.

F8. Erklären Sie den Thread-Pool und seine Verwendung in Java.

Antwort: Der Thread-Pool wird als Thread-Pool bezeichnet. Der Thread wird im Allgemeinen als Arbeitsthread bezeichnet. Die Erstellung eines Threads ist in vielerlei Hinsicht kostspielig, sowohl zeit- als auch ressourcenintensiv. Wenn Sie den Thread zum Zeitpunkt der Prozessanforderung erstellen, verlangsamt dies im Allgemeinen die Antwortzeit des Prozessors und die Anzahl der Threads, die erstellt werden können, ist nur begrenzt begrenzt. Aufgrund dieser beiden Hauptprobleme wurde der Thread-Pool erstellt. In Java können wir mit der Java-API verschiedene Arten von Thread-Pools erstellen, z. B. einen einzelnen Thread-Pool, der jeweils nur einen Prozess ausführt. Der andere ist ein fester Thread-Pool, der eine feste Anzahl von Threads aufnimmt. Dann gibt es einen zwischengespeicherten Thread-Pool, einen erweiterbaren Thread-Pool, der hauptsächlich für viele Aufgaben geeignet ist.

F9. Wie können die Daten zwischen den Threads geteilt werden?

Antwort: Dies sind die beliebtesten Multithreading-Interviewfragen in Java, die in einem Interview gestellt werden. Einige beliebte Testfälle in der aktuellen IT-Branche.

Die Daten können mithilfe des gemeinsam genutzten Objekts oder einer gleichzeitigen Datenstruktur wie einer Blockierungswarteschlange zwischen Threads geteilt werden. Es folgt hauptsächlich dem Producer-Consumer-Muster und verwendet Warte- und Benachrichtigungsmethoden, die die gemeinsame Nutzung eines Objekts zwischen den beiden Threads beinhalten.

F10. Wie werden Threads im Stapel- und Heapspeicher verteilt?

Antwort: In Java verfügt jeder Thread über einen eigenen Stapel, der zum Speichern lokaler Variablen, Methodenparameter und Aufrufstapel verwendet wird. Heap-Speicher ist ein gemeinsamer Speicher, der von allen Threads gemeinsam genutzt wird.

F11. Unterscheiden Sie zwischen einem Thread und einem Prozess.

Antwort:

Feature	Process	Thread
Definition	An autonomous program running.	A process’s lightweight unit.
Execution	Operates on its own.	Operates within a process’s framework.
Communication	Requires communication between processes.	Communication made easier and data space shared.
Synchronization	More remote and possibly requiring more overhead.	Requires shared data synchronization mechanisms.
Resource Overhead	Greater (differing memory spaces).	Lower (shares the process’s resources).
Creation Time	Slower and requiring more resources.	Quicker and with less overhead needed.
Fault Tolerance	More resilient.	Failure could impact the entire process if it is not as strong.

F12. Wofür wird die Java-Methode wait() verwendet?

Antwort: Java verwendet die Methoden notify() und notifyAll() in Verbindung mit der Methode wait(), um Synchronisation und Kommunikation zwischen Threads zu implementieren. Die Object-Klasse, die Basisklasse für alle Java-Klassen, enthält diese Methoden. Unten angegebene Syntax:

public final void wait() throws InterruptedException

Das heißt, wenn Sie wait() verwenden, sollten Sie entweder deklarieren, dass die Methode, die wait() aufruft, diese Ausnahme auslöst, oder die InterruptedException abfangen.

F13. Unterscheiden Sie zwischen dem Benutzer-Thread und dem Daemon-Thread?

Antwort: Ein in Java erstellter Thread wird als Benutzer-Thread bezeichnet. Ein Daemon-Thread läuft immer im Hintergrund und sein vollständiger Lebenszyklus hängt vom Haupt-Thread ab. Ein im Hintergrund laufender Daemon-Thread verhindert nicht, dass JVM ihn beendet. Untergeordnete Threads, die aus einem Daemon-Thread erstellt wurden, sind ebenfalls Daemon-Threads.

F14. Welche verschiedenen Möglichkeiten gibt es, einen Thread in Java zu erstellen?

Antwort:
Threads in Java können auf zwei Arten erstellt werden:

• Durch Erweiterung der Thread-Klasse.

class MyThread extends Thread {
public void run() {
// Code to be executed in the new thread
}
}

// Creating and starting the thread
MyThread myThread = new MyThread();
myThread.start();

• Durch die Implementierung von Runnable Interface.

class MyRunnable implements Runnable {
public void run() {
// Code to be executed in the new thread
}
}

// Creating a thread using the Runnable interface
Thread myThread = new Thread(new MyRunnable());
myThread.start();

F15. Was ist der Lebenszyklus von Thread in JAVA?

Antwort: In Vorstellungsgesprächen werden häufig Java-Interviewfragen zum Thema Multithreading gestellt. Im Folgenden ist der Lebenszyklus eines Threads aufgeführt:

• Neu
• Ausführbar.
• Laufen.
• Blockiert.
• Beendet.

F16. Was passiert, wenn wir die run()-Methode einer Thread-Klasse aufrufen?

Antwort: Durch den direkten Aufruf der run()-Methode wird das Programm erfolgreich kompiliert und ausgeführt, aber dasselbe Programm wird nicht als Thread behandelt, da kein neuer Aufrufstapel erstellt wird und das Programm seinen startet Ausführung im selben Aufrufstapel, in dem der Hauptaufruf ausgeführt wird.

Um einen Thread zu erstellen, der mit einem neuen Aufrufstapel ausgeführt werden soll, muss man die start()-Methode der Thread-Klasse verwenden.

F17. Können wir die Ausführung eines Threads zu einem bestimmten Zeitpunkt anhalten?

Antwort: Ja, dies kann in Java erreicht werden, indem die Funktion „sleep()“ der Thread-Klasse aufgerufen wird. Die Methode „sleep()“ benötigt außerdem ein Argument, das die Zeit in Millisekunden angibt.

F18. Wie können wir die Planung von Threads in Java erreichen?

Antwort: Ja, Thread-Planung in Java ist möglich. Threads in Java können auf zwei Arten geplant werden, nämlich Zeitscheiben und präventive Planung.

Lassen Sie uns mit den nächsten Java-Interviewfragen zum Thema Multithreading fortfahren.

Q19. Kann ein Thread zweimal gestartet werden?

Antwort: Nein, ein Thread kann nicht zweimal gestartet werden. Wenn wir versuchen, einen Thread zweimal zu starten, wird „java.lang.IllegalThreadStateException“ ausgelöst.

Q20. Was ist ein Shutdown-Hook in Java?

Antwort: Dies sind die beliebtesten Java-Interviewfragen zum Thema Multithreading, die in einem Interview gestellt werden. Ein Shutdown-Hook ist ein Mechanismus, der zum Bereinigen von Ressourcen verwendet wird, wenn die JVM normal oder abrupt heruntergefahren wird.

Q21. Was ist volatil?

Antwort: Volatile ist ein Schlüsselwort in Java und kann mit Variablen verwendet werden. Wenn eine Variable als flüchtig deklariert ist, lesen alle Threads den Wert derselben Variablen aus dem Hauptspeicher und nicht aus dem Cache; Dadurch wird das Lesen von Fehlern verhindert, wenn mehrere Threads in ihren Operationen dieselbe Variable verwenden.

Q22. Wie implementiert man einen Thread in JAVA?

Antwort: Java bietet zwei Möglichkeiten, Threads in einem Programm zu implementieren. Die Schnittstelle java.Lang.Runnable verfügt über eine Instanz der Java.lang.A-Zeile, die erfordert, dass eine Aufgabe über eine Instanz ausgeführt wird. Die Thread-Klasse implementiert Runnable bereits, sodass ein Benutzer die run()-Methode direkt überschreiben kann, indem er die Thread-Klasse erweitert oder die Runnable-Schnittstelle implementiert.

Q23. Wann sollte Runnable und wann Thread in Java verwendet werden?

Antwort: Java bietet eine bessere Möglichkeit, die Runnable-Schnittstelle zu implementieren, als die Thread-Klasse zu erweitern, da Java nur eine einzelne Vererbung zulässt. Da eine Klasse mehrere Schnittstellen implementieren, aber nur eine Klasse erweitern kann, bietet dies eine größere Flexibilität beim Teilen von Code zwischen Klassen.

Q24. Warum heißt es, dass Threads Verhalten unvorhersehbar sei?

Antwort: Der Grund dafür ist der Thread-Scheduler, der die Ausführung von Threads übernimmt. Der Scheduler kann auf Windows-, UNIX- und LINUX-Plattformen unterschiedliche Leistungen erbringen. Während der Ausführung kann derselbe Thread auf verschiedenen Plattformen unterschiedliche Ausgaben liefern, manchmal sogar auf derselben Plattform. Um dieses Problem zu lösen, kann ein Benutzer dasselbe Runnable-Objekt erstellen, run()-Schleifen in beiden Threads erstellen und beide Zeilen gemeinsam starten.

Q25. What is a volatile variable in Java, and what is its significance?

Answer: Java facilitates users to share variables present in different threads. A volatile variable acts as a unique modifier that can be used only for instance variables. It provides that a write will happen before any consequent read. The Java memory model ensures the consistency of this variable.

Q26. What is the use of the synchronized keyword? What is the difference between synchronized and volatile keywords?

Answer: The synchronized keyword is used when the goal is to allow only one thread to run at a time in a specific section of code. It can be applied to define four different types of blocks, as shown below:

• Instance methods
• Static methods
• Code blocks inside instance methods
• Code blocks inside static methods

It can be declared as follows:

Public synchronized void example () {}

A volatile variable will never land up in a deadlock as it does not require obtaining any lock. While in synchronized variables, it may end up in a draw if they are not done correctly.

Q27. Why methods like wait(), notify(), and notify all() are present in the object class and not in the Thread class?

Answer: Object class has monitors that allow the Thread to lock an object, while Thread does not have any monitors. The object class’s monitor checks for the thing to see if it is available. Thread class having these methods would not help as multiple threads exist on an object, not vice versa.

Q28. Explain the difference between sleep() and wait() methods.

Answer:

• When the wait() method is called, the monitor moves the Thread from running to waiting for the state. Once a thread is in wait(), then it can move to runnable only when it has notified () or told all () for that object. The scheduler changes the state after this. While in the sleep() method, the state is changed to wait and will return to runnable only after sleep time.
• The wait () method is a part of Java.lang.Object class, while sleep() is a part of Java.lang.Thread class.

Q29. How to force start a thread in Java?

Answer: In Java, multithreading, one cannot force start a thread. Only thread schedulers can control lines and are not exposed to any API for control.

Q30. Does Thread leave object lock when wait() and sleep() methods are called?

Answer: A thread in the sleep() method does not leave the lock and moves to the waiting state. The Thread waits for sleep time to get over.

Q31. Explain the advantages of Multithreading.

Answer :
When it comes to software development, multithreading has several benefits:

1. Enhanced Performance: By utilizing multiple processor cores to execute tasks in parallel, multithreading improves the overall performance of applications.
2. Responsiveness: Multithreading helps applications with graphical user interfaces stay responsive by running background tasks simultaneously.
3. Resource Utilization: By allowing some threads to continue processing while others wait for I/O operations, efficient use of the system’s resources is achieved, maximizing the use of CPU and I/O devices.
4. Maintainability and modularity: Multithreading encourages modular design by assigning distinct threads to handle different functions, which results in code that is easier to read and maintain.
5. Asynchronous Programming: Multithreading makes it possible for tasks to run independently of the main program flow, which is essential for managing events or asynchronous input/output tasks.

Q32. How does time slicing differ from preemptive scheduling?

Answer:
1. Preemptive Scheduling: It is a scheduling technique used by operating systems that allows the system to start or stop a task that is presently underway in order to focus on a higher priority task.

Example: In a preemptive scheduling system, even if a lower-priority task is presently running, it may be preempted from execution if a higher-priority task becomes ready to run.

2. Round Robin Scheduling (Time Slicing): It is a scheduling technique where each process or thread is assigned a fixed time slot or quantum during which it can execute. Once the time slice expires, the next task in the queue is given CPU time.

For instance, if the time slice is set to 10 milliseconds and there are three tasks (A, B, and C), each task receives 10 milliseconds of CPU time in a cyclic fashion (A for 10 ms, then B for 10 ms, and so on).

Q33. What is deadlock?

Answer: Every thread in a system that is waiting for a resource that another waiting thread is holding causes a deadlock. In this case, all of the threads are in a universal waiting state because none of them can continue executing. A deadlock occurs when there is no opportunity for any thread to execute, leading to a halt. Complex circumstances known as deadlocks can impair a program’s regular runtime and possibly lead to coding problems. Maintaining the system’s performance and stability requires controlling and avoiding deadlocks.

Q34. How can a deadlock situation be identified? How is it easily avoidable?

Answer: Tools that display blocked threads, such as thread dumps, can be used to identify deadlocks. TryLock with timeouts, acquiring locks in a consistent order, and reducing lock contention are ways to prevent deadlocks. To lower the chance of deadlocks, properly design multithreaded programs and make use of higher-level concurrency tools.

Q35. Is there a stack for every thread in multithreaded programming?

Answer: Yes, every thread in multithreaded programming has a separate stack. Local variables and details about each thread’s function calls are kept on the stack. Each thread will function independently and have a dedicated area to manage its execution context because of this division.

Q36. How is a thread’s safety achieved?

Answer: A class is considered thread-safe when multiple threads can use its methods or objects concurrently without experiencing conflicts. In multithreaded programming, achieving thread safety is essential to avoiding race situations. This can be done in a few different ways:

• Synchronization: Limiting access to shared resources by employing locks and other mechanisms to make sure that only one thread at a time can access crucial areas.
• Volatile Keyword: Designating variables as volatile ensures consistency by making changes made to the variable by one thread visible to other threads.
• Lock-Based Mechanism: This technique uses explicit locks, like ReentrantLock, to control access to important code segments and stop thread interference.
• Atomic wrapper classes: (such as AtomicInteger and AtomicBoolean) for operations that must be carried out atomically without the need for explicit.

Q37. Tell me the difference between User thread and Daemon thread?

Answer: 

Characteristic	User Threads	Daemon Threads
Creation and Control	created and managed by the user or the application.	The application or user creates and controls these threads, but they can be explicitly set as daemon threads using the setDaemon(true) method.
JVM Termination Impact	JVM will wait for user threads to complete before exiting.	JVM can exit even if daemon threads are still running. Daemon threads are abruptly stopped if all user threads have finished their execution.
Example (Java)	java Thread userThread = new Thread(() -> { /* Thread logic */ }); userThread.start();	java Thread daemonThread = new Thread(() -> { /* Thread logic */ }); daemonThread.setDaemon(true); daemonThread.start();

Q38. How are daemon threads made?

Answer: The Thread class in Java provides the setDaemon(boolean on) method, which can be used to create daemon threads. When all non-daemon threads have finished running, a daemon thread operates in the background and does not stop the Java Virtual Machine (JVM) from shutting down.

Here’s an easy illustration:

public class DaemonThreadExample {
public static void main(String[] args) {
Thread daemonThread = new Thread(() -> {
while (true) {
// Do some background tasks
System.out.println("Daemon Thread is running");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// Setting the thread as daemon
daemonThread.setDaemon(true);
// Starting the daemon thread
daemonThread.start();
// Main thread
System.out.println("Main thread is finished");
}
}

Output:

Explanation:

The daemonThread.setDaemon(true) line in this example designates the thread as a daemon thread. Regardless of its state, the daemon thread will end when the main thread completes its execution and the JVM terminates.

It is crucial to remember that a thread will throw an IllegalThreadStateException if it is not started as a daemon. You are unable to alter a thread’s daemon status once it has begun.

Q39. How do notify() and notifyAll() differ from one another?

Answer:
1. notify():

• Wakes up one of the threads that are currently waiting on the object.
• The scheduling policy of the JVM determines which thread will be notified, and this decision is not guaranteed.

2. notifyAll():

• Wakes up all the threads that are currently waiting on the object.
• Usually makes sure that every thread in line has an opportunity to obtain the lock and verify the altered state.

Q40. What does it mean to be in a deadlock and when can it happen?

Answer: Multiple processes create a deadlock in computing when they become stuck holding resources, waiting for another process to acquire that resource. This situation prevents any progress and results in mutual blocking between the processes.

When the following four requirements referred to as the Coffman conditions—are satisfied, a deadlock usually results:

• Mutual Exclusion: One or more resources must be kept in a non-sharable mode, which limits the resource’s use to a single process at a time.
• Hold and Wait: A process needs to be holding one resource at a time while it waits to obtain more resources that other processes are holding.
• No Preemption: Resources must be released willingly from a process; they cannot be taken away by force.
• Circular Wait: When two or more processes are in a circular chain, each process is waiting for a resource that the subsequent process in the chain is holding.

Das obige ist der detaillierte Inhalt vonMultithreading-Interviewfragen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!