Die 50 wichtigsten Fragen und Antworten zu Java Core-Interviews. Teil 2

Die 50 wichtigsten Fragen und Antworten zu Java Core-Interviews. Teil 1

Sammlungen

25. Was versteht man unter Sammlungen in Java?

Collection ist ein Framework, das zum Speichern und Bearbeiten von Objekten dient. Wird verwendet, um die folgenden Vorgänge auszuführen:

• suchen;
• Sortierung;
• Manipulation;
• Zusatz;
• Streichung.

Alle Klassen und Schnittstellen für das Collection-Framework sind im java.utilPaket enthalten.

26. Welche Klassen und Schnittstellen sind im Collection-Framework verfügbar?

Schnittstellen:

• Sammlung;
• Aufführen;
• Satz;
• Karte;
• Sortiertes Set;
• Sortierte Karte;
• Warteschlange.

Klassen:

• Listen:
  1. Anordnungsliste;
  2. LinkedList;
  3. Vektor (veraltet).
• Sets:
  1. HashSet;
  2. LinkedHashSet;
  3. TreeSet.
• Karten:
  1. HashMap
  2. TreeMap
  3. HashTable (veraltet)
  4. LinkedHashMap
• Warteschlange
  1. Prioritätswarteschlange.

27. Was versteht man unter sortiert und geordnet in Sammlungen?

Bestellt:

Dies bedeutet, dass die in der Sammlung gespeicherten Elemente auf den zur Sammlung hinzugefügten Werten basieren. Auf diese Weise können wir die Werte aus der Sammlung in einer bestimmten Reihenfolge durchlaufen. Mit anderen Worten bedeutet dies, dass die Elemente der Sammlung ihre eigene spezifische Reihenfolge haben, nach der sie angeordnet sind. Zum besseren Verständnis speichert eine Sammlung, die nicht geordnet ist, ihre Elemente in zufälliger Reihenfolge. Beispiel: Set.

Sortiert:

Dies bedeutet, dass eine Gruppe von Elementen basierend auf den Daten des Sammlungselements in eine Sammlung sortiert wird. Das heißt, nicht nur die Sammlung ist geordnet, sondern auch die Reihenfolge der Elemente hängt von ihren Werten ab. Diese Reihenfolge kann sich ändern, wenn Sie nach einem anderen Elementwert sortieren.

28. Welche Sammlungen gibt es mit einer List-Schnittstelle? Wie arbeiten Sie mit List?

Die Werte der Elemente in einem Blatt basieren auf ihrem Index – sie sind nach Index geordnet. Wiederholungen von Elementen sind zulässig (das heißt, Sie können dasselbe Objekt mehrmals zur Sammlung hinzufügen und es ist kein Problem).

Anordnungsliste:

Die häufigste Sammlung. Im Wesentlichen handelt es sich um ein Array mit dynamisch wachsender Größe. Die Aufgabe, die Größe des Arrays zu verwalten, obliegt der Sammlung. Für uns ist es wichtig zu verstehen, dass wir in den meisten Fällen dies verwenden müssen. Besonderheiten:

• schnelle Suche und schnelle Indexsuche;
• die Sammlung ist nach Index geordnet, aber nicht sortiert;
• implementiert die RandomAccess-Schnittstelle;
• langsam zur Mitte der Liste hinzufügen.

Beispiel:

public class A {

   public static void main(String[] args) {
       ArrayList names = new ArrayList<>();
       names.add("John");
       names.add("John");
       names.add("Roman");
       names.add("Ivan");
   }

}

>> Ausgabe

   [John, John, Roman, Ivan]

Die Ausgabe zeigt, dass es sich um wiederholbare Elemente handelt. Sie werden in der Reihenfolge angezeigt, in der sie aufgezeichnet wurden. Was gibt es sonst noch zu lesen? Ja, es gibt viele Informationen, Sie müssen JavaRush nicht einmal verlassen:

• Detaillierte Analyse der ArrayList-Klasse
• ArrayList-Klasse
• Funktionierende ArrayList in Bildern
• ArrayList in Java

Verlinkte Liste:

Dies ist eine Sammlung, in der jedes Element einen Link zum vorherigen und nächsten Element hat. Mit diesen Links können Sie von einem Element zum anderen wechseln. Beim Hinzufügen eines Elements ändern sich einfach die Links zum vorherigen und nächsten Element:

• Elemente sind miteinander verbunden, d. h. es wird eine doppelt verknüpfte Liste implementiert.
• die Gesamtgeschwindigkeit ist deutlich geringer als bei ArrayList;
• eine ausgezeichnete Wahl für eine große Anzahl von Einfügungen und Löschungen in der Mitte eines Arrays;
• implementiert die Queue- und Deque-Listenschnittstellen und verfügt daher über eigene Arbeitsmethoden.

Beispiel:

LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("One");
linkedList.add("Two");
linkedList.add("Three");

29. Erzählen Sie uns etwas über die Kartensammlung und ihre Implementierungen?

Map ist eine Schlüsselwertsammlung. Es gibt einen eindeutigen Schlüssel und einen Wert, der diesem Wert entspricht. equals()Methoden werden auch verwendet hashcode(), um die Eindeutigkeit eines Schlüssels zu bestimmen.

HashMap:

• nicht sortiert oder geordnet;
• wird verwendet, wenn Reihenfolge und Sortierung nicht wichtig sind;
• unterstützt Nullschlüssel.

Beispiel:

public class CollectionExample {

   public static void main(String[] args) {
       HashMap positions = new HashMap<>();
       positions.put("junior", "Ivan");
       positions.put("middle", "Roman");
       positions.put("senior", "Vasily");
       positions.put("team lead", "Anton");
       positions.put("arthitect", "Andrew");
       positions.put("senior", "John");
       System.out.println(positions);
   }
}

// вывод в консоль
// {junior=Ivan, middle=Roman, senior=John, team lead=Anton, arthitect=Andrew}

Die Schlüssel sind immer eindeutig, daher wird nur ein Senior erfasst.

LinkedHashMap:

• behält die Einfügungsreihenfolge bei;
• langsamer als HashMap;
• Es wird erwartet, dass die Iteration schneller ist als in HashMap.

Beispiel:

public class CollectionExample {

   public static void main(String[] args) {
       LinkedHashMap<String, String> positions = new LinkedHashMap<>();
       positions.put("junior", "Ivan");
       positions.put("middle", "Roman");
       positions.put("senior", "Vasily");
       positions.put("team lead", "Anton");
       positions.put("arthitect", "Andrew");
       positions.put("senior", "John");
       System.out.println(positions);
   }
}

// вывод в консоль
// {junior=Ivan, middle=Roman, senior=John, team lead=Anton, arthitect=Andrew}

Baumkarte:

Eine Kartenimplementierung, die die Einträge entsprechend der natürlichen Reihenfolge ihrer Schlüssel sortiert hält, oder noch besser, mithilfe eines Komparators, sofern einer im Konstruktor beim Erstellen der Karte bereitgestellt wird. Beispiel:

1. Ohne Komparator

   public class CollectionExample {
   
      public static void main(String[] args) {
          TreeMap<Integer, String> positions = new TreeMap<>();
          positions.put(1, "Ivan");
          positions.put(3, "Roman");
          positions.put(2, "Vasily");
          positions.put(10, "Anton");
          positions.put(7, "Andrew");
          positions.put(1, "John");
          System.out.println(positions);
      }
   }
   
   // вывод в консоль
   // {1=John, 2=Vasily, 3=Roman, 7=Andrew, 10=Anton}

2. Mit Komparator

   public class CollectionExample {
   
      public static void main(String[] args) {
          //используем реализацию Strategy Pattern'a и добавим компаратор:
          TreeMap<Integer, String> positions = new TreeMap<>(Comparator.reverseOrder());
          positions.put(1, "Ivan");
          positions.put(3, "Roman");
          positions.put(2, "Vasily");
          positions.put(10, "Anton");
          positions.put(7, "Andrew");
          positions.put(1, "John");
          System.out.println(positions);
      }
   }
   
   // вывод в консоль
   // {10=Anton, 7=Andrew, 3=Roman, 2=Vasily, 1=John}

Wir sehen, dass die Sortierung in aufsteigender Reihenfolge standardmäßig implementiert ist, dies kann jedoch geändert werden, indem dem Konstruktor ein Komparator hinzugefügt wird. TreeMap wird hier gut beschrieben .

30. Erzählen Sie uns etwas über die Set-Sammlung und ihre Implementierungen?

Ein Set ist eine Reihe einzigartiger Elemente, und das ist sein Hauptmerkmal. Das heißt, Set lässt nicht zu, dass dieselben Elemente wiederholt werden. Wichtig hierbei ist, dass die hinzugefügten Objekte über eine implementierte Methode verfügen equals .

HashSet:

• nicht sortiert oder geordnet. Unter der Haube befindet sich eine HashMap mit einem Platzhalter für den Wert. Überzeugen Sie sich selbst ;)
• verwendet HashCode, um Objekte hinzuzufügen;
• Es sollte verwendet werden, wenn Sie einzigartige Objekte benötigen und deren Reihenfolge nicht wichtig ist.

Beispiel:

public class CollectionExample {

   public static void main(String[] args) {
       HashSet<String> positions = new HashSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [senior, middle, team lead, architect, junior]

Hier sieht man, dass das „Junior“-Element, das zweimal hinzugefügt wurde, nur in einer einzigen Instanz vorhanden ist. Und die Reihenfolge ist nicht die gleiche wie beim Hinzufügen.

LinkedHashSet:

• bestellte Version von HashSet;
• unterstützt doppelt verknüpfte Listen für alle Elemente;
• Verwenden Sie es, wenn Sie Ordnung in Ihrer Iteration benötigen.

Beispiel:

public class CollectionExample {

   public static void main(String[] args) {
       LinkedHashSet<String> positions = new LinkedHashSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [senior, middle, team lead, architect, junior]

TreeSet:

• eine von zwei sortierten Sammlungen;
• verwendet eine rot-schwarze Baumstruktur und stellt sicher, dass die Elemente in aufsteigender Reihenfolge sind;
• Unter der Haube befindet sich eine TreeMap mit einem Stub zu den Werten. Und die Elemente des TreeSet sind die Schlüssel zur TreeMap (siehe auch ;)).

Beispiel:

public class CollectionExample {

   public static void main(String[] args) {
       TreeSet<String> positions = new TreeSet<>();
       positions.add("junior");
       positions.add("junior");
       positions.add("middle");
       positions.add("senior");
       positions.add("team lead");
       positions.add("architect");
       System.out.println(positions);
   }
}

// вывод в консоль
// [architect, junior, middle, senior, team lead]

Ausnahmen

31. Was ist eine Ausnahme?

Eine Ausnahme ist ein Problem, das zur Laufzeit auftreten kann. Dies ist eine Ausnahmesituation , die aus irgendeinem Grund entsteht. Das Ausnahmevererbungsdiagramm sieht so aus (Sie müssen es auswendig kennen ;)): Das Diagramm zeigt, dass im Allgemeinen alle Ausnahmen in zwei Gruppen unterteilt sind – Ausnahmen und Fehler. Fehler – JVMs werden verwendet, um Fehler anzuzeigen, nach denen die Anwendung keinen Sinn mehr ergibt. Zum Beispiel StackOverFlowError, der besagt, dass der Stapel voll ist und das Programm nicht mehr ausgeführt werden kann. Ausnahme – Ausnahmen, die programmgesteuert im Code generiert werden. Es gibt verschiedene Ausnahmen, aktivierte und nicht aktivierte, aber die Hauptsache ist, dass sie existieren, abgefangen werden können und die Anwendung weiterhin funktionieren kann. Ausnahmen wiederum werden weiter unterteilt in Ausnahmen, die von RuntimeException und anderen Nachkommen von Exception erben. Es gibt genügend Informationen zu diesem Thema. Im Folgenden besprechen wir, welche aktivierten/ungeprüften Ausnahmen es gibt.

32. Wie geht die JVM mit Ausnahmen um?

Wie es funktioniert? Sobald irgendwo eine Ausnahme ausgelöst wird, erstellt die Laufzeit ein Ausnahmeobjekt (bezeichnet als ExcObj). Es speichert alle für die Arbeit notwendigen Informationen – die Ausnahme selbst, die ausgelöst wurde, und den Ort, an dem sie aufgetreten ist. Die Erstellung ExcObjund Übertragung zur Laufzeit ist nichts anderes als das „Auslösen einer Ausnahme“. ExcObjenthält Methoden, mit denen man an die Stelle gelangen kann, an der die Ausnahme ausgelöst wurde. Dieser Methodensatz wird Call Stack genannt. Als nächstes sucht das Laufzeitsystem im Call Stack nach einer Methode, die unsere Ausnahme behandeln kann. Wenn ein entsprechender Handler gefunden wird, d. h. der Ausnahmetyp mit dem Typ im Handler übereinstimmt, ist alles in Ordnung. Wenn es nicht gefunden wird, übergibt die Laufzeit alles an den Standard-Ausnahmebehandler, der eine Antwort vorbereitet und beendet. So sieht es aus:

/**
* Пример, в котором показываются две опции — когда находится обработчик для исключения и когда нет.
*/
class ThrowerExceptionExample {

   public static void main(String[] args) throws IllegalAccessException {

       ThrowerExceptionExample example = new ThrowerExceptionExample();

       System.out.println(example.populateString());
   }

   /**
    * Здесь происходит перехват одного из возможных исключений — {@link IOException}.
    * А вот второй будет пробрасываться дальше вверх по вызову.
    */
   private String populateString() throws IllegalAccessException {
       try {
           return randomThrower();
       } catch (IOException e) {
           return "Caught IOException";
       }
   }

   /**
    * Здесь две опции: oder бросается {@link IOException} oder {@link IllegalAccessException}.
    * Выбирается случайным образом.
    */
   private String randomThrower() throws IOException, IllegalAccessException {
       if (new Random().nextBoolean()) {
           throw new IOException();
       } else {
           throw new IllegalAccessException();
       }
   }
}

In unserem Fall sieht CallStack schematisch so aus:

randomThrower() => populateString() => main(String[] args)

Es gibt zwei Möglichkeiten: Die eine oder andere Ausnahme wird zufällig ausgelöst. Für IOException ist alles in Ordnung. Wenn es generiert wird, lautet das Ergebnis der Arbeit: "Caught IOException". Wenn es jedoch eine zweite Ausnahme gibt, für die es keinen Handler gibt, stoppt das Programm mit der folgenden Ausgabe:

Exception in thread "main" java.lang.IllegalAccessException
  at ThrowerExceptionExample.randomThrower(CollectionExample.java:38)
  at ThrowerExceptionExample.populateString(CollectionExample.java:24)
  at ThrowerExceptionExample.main(CollectionExample.java:15)

33. Wie gehen Programmierer mit Ausnahmen um?

In den obigen Fragen wurden bereits bestimmte Schlüsselwörter verwendet, um mit Ausnahmen zu arbeiten; nun müssen wir näher darauf eingehen. Was sind die Schlüsselwörter?

• versuchen
• fangen
• werfen
• wirft
• Endlich

Es ist wichtig zu beachten, dass Catch, Throw und Throws nur mit java.lang.Throwable verwendet werden können. Bei anderen Typen funktioniert das nicht. Jetzt besprechen wir „Versuchen“, „Fangen“ und „Endlich“.

• try-catch-finallyist ein Konstrukt, mit dem Sie eine Ausnahme korrekt abfangen und behandeln können.
• try- Es kann nur eine Zeit geben, da geschieht die Logik;
• catch– ein Block, der irgendeine Art von Ausnahme empfängt; davon kann es viele geben. Beispielsweise löst ein Try-Block mehrere Ausnahmen aus, die nichts miteinander zu tun haben.
• finally- „endlich“ dieser Block. Dies ist ein Block, der auf jeden Fall ausgeführt wird, unabhängig davon, was in try, Catch gemacht wird.

So sieht es aus:

try {
   // сюда передают тот Code, который может вызвать исключение.
} catch (IOException e) {
   // первый catch блок, который принимает IOException и все его подтипы(потомки).
   // Например, нет Datei при чтении, выпадает FileNotFoundException, и мы уже соответствующе
   // обрабатываем это.
} catch (IllegalAccessException e) {
   // если нужно, можно добавить больше одного catch блока, в этом нет проблем.
} catch (OneException | TwoException e) {
   // можно даже объединять несколько в один блок
} catch (Throwable t) {
   // а можно сказать, что мы принимаем ВСЁ))))
} finally {
   // этот блок может быть, а может и не быть.
   // и он точно выполнится.
}

Lesen Sie die Beschreibung des Beispiels sorgfältig durch und alles wird klar)

34. Werfen und Würfen in Java

werfen

throwWird verwendet, wenn Sie explizit eine neue Ausnahme erstellen müssen. Es wird zum Erstellen und Auslösen benutzerdefinierter Ausnahmen verwendet. Zum Beispiel Ausnahmen im Zusammenhang mit der Validierung. Normalerweise erben sie zur Validierung von RuntimeException. Beispiel:

// пример пробрасывания исключения
throw new RuntimeException("because I can :D");

Es ist wichtig, dass diese Konstruktion nur von etwas verwendet werden kann, das von erbt Throwable. Das heißt, man kann das nicht sagen:

throw new String("Wie тебе такое, Илон Маск?");

Als nächstes wird die Arbeit des Threads beendet und die Suche nach einem Handler beginnt, der ihn verarbeiten könnte. Wenn es es nicht findet, geht es zu der Methode, die es aufgerufen hat, und so geht die Suche in der Aufrufreihe nach oben, bis es entweder den entsprechenden Handler findet oder die Anwendung laufen lässt. Lass uns nachsehen:

// Пример, который демонстрирует работу throw
class ThrowExample {

   void willThrow() throws IOException {
       throw new IOException("Because I Can!");
   }

   void doSomething() {
       System.out.println("Doing something");
       try {
           willThrow();
       } catch (IOException e) {
           System.out.println("IOException was successfully handled.");
       }
   }

   public static void main(String args[]) {
       ThrowExample throwExample = new ThrowExample();
       throwExample.doSomething();
   }
}

Wenn wir das Programm ausführen, erhalten wir folgendes Ergebnis:

Doing something
IOException was successfully handled.

wirft

throws– ein Mechanismus, mit dem eine Methode eine oder mehrere Ausnahmen auslösen kann. Sie werden durch Kommas getrennt hinzugefügt. Mal sehen, wie einfach und unkompliziert es ist:

private Object willThrow() throws RuntimeException, IOException, FileNotFoundException

Darüber hinaus ist zu beachten, dass es sowohl aktivierte als auch nicht aktivierte Ausnahmen geben kann. Natürlich dürfen keine ungeprüften Ausnahmen hinzugefügt werden throws, aber gute Manieren sagen etwas anderes. Wenn es sich um überprüfbare Elemente handelt, müssen Sie sie mithilfe der Methode, die sie generiert, irgendwie verarbeiten. Es gibt zwei Möglichkeiten:

1. Schreiben Sie try-catchmit der entsprechenden und oben genannten Vererbungsausnahme.
2. Verwenden Sie es throwsgenauso, damit jemand anderes dieses Problem bereits hat :D

35. Geprüfte und ungeprüfte Ausnahmen in Java

In Java gibt es zwei Arten von Ausnahmen: aktivierte und nicht aktivierte.

Geprüfte Ausnahmen:

Dies sind Ausnahmen, die zur Kompilierzeit überprüft werden. Wenn ein Code in einer Methode während einer Ausnahme eine geprüfte Ausnahme auslöst, muss die Methode diese entweder mit verarbeiten try-catchoder weiterleiten. Wenn beispielsweise ein Bild aus dem Pfad „/users/romankh3/image.png“ gelesen wird, wird es aktualisiert auf irgendeine Weise (für uns ist das nicht wichtig) und speichert es zurück.

class CheckedImageExample {
   public static void main(String[] args) {
       File imageFile = new File("/users/romankh3/image.png");
       BufferedImage image = ImageIO.read(imageFile);
       updateAndSaveImage(image, imageFile);
   }

   private static void updateAndSaveImage(BufferedImage image, File imageFile) {
       ImageIO.write(image, "png", imageFile);
   }
}

Ein solcher Code lässt sich nicht kompilieren, da statische Methoden eine IOException ImageIO.read()auslösen ImageIO.write(), die überprüft wird und entsprechend behandelt werden muss. Hier gibt es zwei Möglichkeiten, die wir oben bereits besprochen haben: entweder verwenden try-catchoder weiterleiten. Zur besseren Assimilation werden wir dies und das tun. Das heißt, updateAndSavewir leiten es einfach in der Methode weiter und verwenden es dann in der Hauptmethode try-catch:

class CheckedImageExample {
   public static void main(String[] args) {
       File imageFile = new File("/users/romankh3/image.png");
       try {
           BufferedImage image = ImageIO.read(imageFile);
           updateAndSaveImage(image, imageFile);
       } catch (IOException e) {
           e.printStackTrace();
       }
   }

   private static void updateAndSaveImage(BufferedImage image, File imageFile) throws IOException {
       ImageIO.write(image, "png", imageFile);
   }
}

Ungeprüfte Ausnahmen:

Dies sind die Ausnahmen, die in der Kompilierungsphase nicht überprüft werden. Das heißt, eine Methode kann eine RuntimeException generieren, aber der Compiler wird Sie nicht daran erinnern, irgendwie damit umzugehen. Wie unten gezeigt, ist alles, was von RuntimeException und Error erbt, deaktiviert. Betrachten Sie das folgende Java-Programm. Der Code lässt sich gut kompilieren, löst jedoch beim Ausführen eine Ausnahme aus ArrayIndexOutOfBoundsException. Der Compiler lässt die Kompilierung zu, da ArrayIndexOutOfBoundsExceptiones sich um eine ungeprüfte Ausnahme handelt. Eine häufige Situation bei einem Array, die sein könnte:

class CheckedImageExample {
   public static void main(String[] args) {
       int[] array = new int[3];
       array[5] = 12;
   }
}

Das Ergebnis wird sein:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
  at main(CheckedImageExample.java:12)

Ist Ihnen übrigens schon aufgefallen, dass in Java keine Kurznamen vergeben werden? Je mehr desto besser. Er, Spring Framework, war darin sehr erfolgreich: Nehmen Sie einfach eine BeanFactoryPostProcessor- Klasse)))

36. Was sind Try-with-Ressourcen?

Dabei handelt es sich um einen Mechanismus, bei dem alle Ressourcen korrekt geschlossen werden müssen. Es ist irgendwie nicht klar, oder?) Zunächst einmal: Was ist eine Ressource? Eine Ressource ist ein Objekt, mit dem Sie es nach der Arbeit schließen, also aufrufen müssen close(). Eine Ressource bezieht sich auf alle Objekte, die eine Schnittstelle implementieren AutoClosable, die wiederum eine Schnittstelle implementiert Closeable. Für uns ist es wichtig zu verstehen, dass alles eine Ressource InputStreamist OutpuStreamund korrekt und erfolgreich freigegeben werden muss. try-with-resourceGenau aus diesem Grund müssen wir die Struktur nutzen . So sieht es aus:

private void unzipFile(File zipFile) throws IOException {
   try(ZipInputStream zipOutputStream = new ZipInputStream(new FileInputStream(zipFile))) {
       ZipEntry zipEntry = zipOutputStream.getNextEntry();
       while (zipEntry != null) {

       }
   }
}

private void saveZipEntry(ZipEntry zipEntry) {
   // логика сохранения
}

In diesem Beispiel ist die Ressource ZipInputStream, nach der Arbeit mit der Sie sie schließen müssen. Und um nicht über den Aufruf der Methode nachzudenken close(), definieren wir diese Variable einfach in einem Try-Block, wie im Beispiel gezeigt, und innerhalb dieses Blocks erledigen wir alles Notwendige. Was bewirkt das Beispiel? Das Zip-Archiv wird entpackt. Dazu müssen Sie InputStream'om' verwenden. Sie können mehr als eine Variable definieren; diese werden durch ein Semikolon getrennt. Was ist das Problem? Aber man kann finallyeinen Block verwenden, könnte man sagen. Hier ist ein Artikel , der die Probleme bei diesem Ansatz detailliert beschreibt. Es beschreibt auch die gesamte Liste der Fehler, die jemandem passieren können, der dieses Design nicht verwendet. Ich empfehle die Lektüre ;) Im letzten Teil gibt es Fragen/Antworten zum Thema Multithreading. Mein GitHub-Profil