{"id":51,"date":"2023-09-30T14:25:00","date_gmt":"2023-09-30T13:25:00","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=51"},"modified":"2024-01-08T09:15:25","modified_gmt":"2024-01-08T08:15:25","slug":"effiziente-nebenlaeufigkeit-mit-thread-pools-und-executors-in-java","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=51","title":{"rendered":"Effiziente Nebenl\u00e4ufigkeit mit Thread-Pools und Executors in Java"},"content":{"rendered":"\n

In der Welt der Softwareentwicklung spielt die effiziente Verarbeitung von Aufgaben eine entscheidende Rolle. Die M\u00f6glichkeit, Aufgaben parallel abzuarbeiten, verbessert die Leistung von Anwendungen erheblich. Java, als eine der f\u00fchrenden Programmiersprachen, bietet Mechanismen zur Nebenl\u00e4ufigkeit, darunter Thread-Pools und Executors, welche gegen\u00fcber den einfachen Threads wie in diesem Artikel<\/a> beschrieben oft zu bevorzugen sind. Dieser Artikel hier widmet sich daher nun der Erkl\u00e4rung und Demonstration dieser Konzepte und zeigt, wie sie in Java verwendet werden k\u00f6nnen, um skalierbare und leistungsstarke Anwendungen zu entwickeln.<\/p>\n\n\n\n

    \n
  1. Grundlagen der Nebenl\u00e4ufigkeit in Java:<\/strong> Bevor wir uns mit Thread-Pools und Executors befassen, ist es wichtig, die Grundlagen der Nebenl\u00e4ufigkeit in Java zu verstehen. Ein Thread repr\u00e4sentiert einen ausf\u00fchrbaren Codepfad innerhalb eines Programms. Die Erstellung und Verwaltung von Threads erm\u00f6glichen es, Aufgaben gleichzeitig auszuf\u00fchren. Allerdings kann eine \u00fcberm\u00e4\u00dfige Anzahl von Threads zu Ressourcenengp\u00e4ssen und ineffizienter Nutzung der Systemressourcen f\u00fchren.<\/li>\n\n\n\n
  2. Thread-Pools:<\/strong> Ein Thread-Pool ist eine Sammlung vorab erstellter Threads, die dazu verwendet werden, Aufgaben aus einer Warteschlange auszuf\u00fchren. Die Idee besteht darin, die Anzahl der Threads zu begrenzen und sie wiederzuverwenden, um eine bessere Kontrolle \u00fcber die Nebenl\u00e4ufigkeit zu haben. Java stellt die ExecutorService<\/code>-Schnittstelle bereit, um Thread-Pools zu erstellen und zu verwalten. Beispielcode f\u00fcr die Erstellung eines einfachen Thread-Pools:<\/li>\n<\/ol>\n\n\n
       int poolSize = 5;\n   ExecutorService executor = Executors.newFixedThreadPool(poolSize);<\/code><\/span><\/pre>\n\n\n
    Hier wird ein Thread-Pool mit einer festen Gr\u00f6\u00dfe von f\u00fcnf Threads erstellt. Die Gr\u00f6\u00dfe des Pools sollte je nach Anforderungen und Systemressourcen sorgf\u00e4ltig gew\u00e4hlt werden.<\/p>\n\n\n\n
      \n
    1. Executors in Java:<\/strong> Executors sind eine h\u00f6here Ebene der Abstraktion \u00fcber Thread-Pools und bieten einen vereinfachten Mechanismus zur Ausf\u00fchrung von Aufgaben nebenl\u00e4ufig. Java stellt verschiedene Implementierungen von ExecutorService<\/code> zur Verf\u00fcgung, die den unterschiedlichen Anforderungen gerecht werden.<\/li>\n<\/ol>\n\n\n\n
        \n
      • newFixedThreadPool(int nThreads)<\/code>: Erstellt einen Thread-Pool mit fester Gr\u00f6\u00dfe.<\/li>\n\n\n\n
      • newCachedThreadPool()<\/code>: Erstellt einen dynamisch wachsenden Thread-Pool.<\/li>\n\n\n\n
      • newSingleThreadExecutor()<\/code>: Erstellt einen Thread-Pool mit nur einem Thread. Beispielcode f\u00fcr die Verwendung von Executors:<\/li>\n<\/ul>\n\n\n
           ExecutorService executor = Executors.newFixedThreadPool(3);\n\n   for (int i = 0; i < 10<\/span>; i<\/span>++) {\n       Runnable<\/span> task<\/span> = new<\/span> MyTask<\/span>(i<\/span>);\n       executor.execute<\/span>(task<\/span>);\n   }\n\n   executor.shutdown<\/span>();<\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
        Hier wird ein Thread-Pool mit fester Gr\u00f6\u00dfe erstellt, und zehn Aufgaben (repr\u00e4sentiert durch MyTask<\/code>) werden dem Pool zur Ausf\u00fchrung \u00fcbergeben. Nach Abschluss aller Aufgaben wird der Thread-Pool heruntergefahren.<\/p>\n\n\n\n
          \n
        1. Arbeiten mit Callable und Future:<\/strong> Neben der Ausf\u00fchrung von Runnable-Aufgaben k\u00f6nnen Thread-Pools auch Callable-Aufgaben verarbeiten, die einen Wert zur\u00fcckgeben. Die Callable<\/code>-Schnittstelle wird in Verbindung mit der Future<\/code>-Schnittstelle verwendet, um das Ergebnis einer Aufgabe abzurufen. Beispielcode f\u00fcr die Verwendung von Callable und Future:<\/li>\n<\/ol>\n\n\n
             Callable<Integer> task = () -> {\n       \/\/ Aufgabe, die einen Wert zur\u00fcckgibt<\/span>\n       return<\/span> 42<\/span>;\n   };\n\n   Future<Integer> futureResult = executor.submit(task);\n\n   try<\/span> {\n       Integer result = futureResult.get(); \/\/ Blockiert, bis das Ergebnis verf\u00fcgbar ist<\/span>\n       System.out.println(\"Ergebnis: \"<\/span> + result);\n   } catch<\/span> (InterruptedException | ExecutionException e) {\n       e.printStackTrace();\n   }<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
          Hier wird eine Callable-Aufgabe erstellt, die einen Integer-Wert zur\u00fcckgibt. Das submit<\/code>-Methode gibt ein Future<\/code>-Objekt zur\u00fcck, das verwendet werden kann, um das Ergebnis abzurufen.<\/p>\n\n\n\n
            \n
          1. Individuelle Benennung von Threads in Thread-Pools:<\/strong> Bei der Verwendung von Thread-Pools ist es oft hilfreich, Threads individuell zu benennen, um ihre Aufgaben besser zu verfolgen und zu verstehen. In Java k\u00f6nnen Sie dies erreichen, indem Sie eine benutzerdefinierte ThreadFactory<\/code> implementieren und dem Thread-Pool bei der Erstellung \u00fcbergeben. Beispielcode f\u00fcr die individuelle Benennung von Threads:<\/li>\n<\/ol>\n\n\n
               class<\/span> NamedThreadFactory<\/span> implements<\/span> ThreadFactory<\/span> <\/span>{\n       private<\/span> static<\/span> int threadCount = 0<\/span>;\n       private<\/span> String prefix;\n\n       public<\/span> NamedThreadFactory(String prefix) {\n           this.prefix = prefix;\n       }\n\n       @Override\n       public<\/span> Thread newThread(Runnable r) {\n           Thread thread = new<\/span> Thread(r, prefix + \"-\"<\/span> + threadCount);\n           threadCount++;\n           return<\/span> thread;\n       }\n   }<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
            Hier wird eine einfache NamedThreadFactory<\/code> implementiert, die Threads mit einem benutzerdefinierten Pr\u00e4fix und einer fortlaufend erh\u00f6hten Nummer erstellt. Diese Factory kann dann dem Thread-Pool bei der Initialisierung \u00fcbergeben werden.<\/p>\n\n\n
               ExecutorService executor = Executors.newFixedThreadPool(3<\/span>, new<\/span> NamedThreadFactory(\"MyThread\"<\/span>));<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
            Nun werden die Threads im Pool mit Namen wie „MyThread-0“, „MyThread-1“, usw. benannt.<\/p>\n\n\n\n
            Die Nutzung von Thread-Pools und Executors in Java erm\u00f6glicht eine effiziente Verarbeitung von Aufgaben durch die Kontrolle der Nebenl\u00e4ufigkeit. Durch die Verwendung vorab erstellter Threads und h\u00f6herer Abstraktionsebenen wie Executors k\u00f6nnen Entwickler leistungsf\u00e4hige Anwendungen erstellen, die gut skaliert und ressourceneffizient sind. Die individuelle Benennung von Threads bietet eine zus\u00e4tzliche Ebene der Transparenz und Verst\u00e4ndlichkeit in komplexen Anwendungen, indem sie erm\u00f6glicht, die Aufgaben einzelnen Threads zuzuordnen. Es ist jedoch wichtig, sich der Herausforderungen der Nebenl\u00e4ufigkeit bewusst zu sein, insbesondere in Bezug auf die Thread-Sicherheit, um unerw\u00fcnschte Ergebnisse zu vermeiden.<\/p>\n","protected":false},"excerpt":{"rendered":"
            In der Welt der Softwareentwicklung spielt die effiziente Verarbeitung von Aufgaben eine entscheidende Rolle. Die M\u00f6glichkeit, Aufgaben parallel abzuarbeiten, verbessert die Leistung von Anwendungen erheblich. Java, als eine der f\u00fchrenden Programmiersprachen, bietet Mechanismen zur Nebenl\u00e4ufigkeit, darunter Thread-Pools und Executors, welche gegen\u00fcber den einfachen Threads wie in diesem Artikel beschrieben oft zu bevorzugen sind. Dieser Artikel […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-51","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/51","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=51"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/51\/revisions"}],"predecessor-version":[{"id":52,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/51\/revisions\/52"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=51"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=51"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=51"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}