Java Timer vs ExecutorService?

Wenn es Ihnen zur Verfügung steht, ist es schwierig, sich einen Grund vorzustellen nicht um das Executor-Framework Java 5) zu verwenden.

ScheduledExecutorService ex = Executors.newSingleThreadScheduledExecutor();

gibt Ihnen ein ScheduledExecutorService mit einer ähnlichen Funktionalität wie Timer (dh es wird ein Thread sein), dessen Zugriff jedoch möglicherweise etwas skalierbarer ist (unter der Haube werden eher gleichzeitige Strukturen als vollständige Synchronisation verwendet) wie bei der Klasse Timer). Die Verwendung eines ScheduledExecutorService bietet Ihnen auch folgende Vorteile:

• Sie können es bei Bedarf anpassen (siehe die Klasse newScheduledThreadPoolExecutor() oder ScheduledThreadPoolExecutor)
• Die "einmaligen" Ausführungen können Ergebnisse zurückgeben

Die einzigen Gründe, an Timer festzuhalten, die mir einfallen, sind:

• Es ist verfügbar vor Java 5
• In J2ME ist eine ähnliche Klasse enthalten, die die Portierung Ihrer Anwendung erleichtern könnte (in diesem Fall wäre es jedoch nicht besonders schwierig, eine gemeinsame Abstraktionsebene hinzuzufügen).

ExecutorService ist neuer und allgemeiner. Ein Timer ist nur ein Thread, der regelmäßig die von Ihnen geplanten Aufgaben ausführt.

Ein ExecutorService kann ein Thread-Pool sein oder sich sogar auf andere Systeme in einem Cluster verteilen und Dinge wie die einmalige Batch-Ausführung usw. ausführen.

Schauen Sie sich einfach an, was jeder anbietet, um sich zu entscheiden.

Hier sind einige weitere bewährte Methoden zur Verwendung des Timers:

http://tech.puredanger.com/2008/09/22/timer-rules/

Im Allgemeinen würde ich Timer für schnelle und schmutzige Dinge und Executor für eine robustere Nutzung verwenden.

Von der Oracle-Dokumentationsseite auf ScheduledThreadPoolExecutor

Ein ThreadPoolExecutor , der zusätzlich Befehle zur Ausführung nach einer bestimmten Verzögerung oder zur periodischen Ausführung einplanen kann. Diese Klasse ist Timer vorzuziehen, wenn mehrere Arbeitsthreads benötigt werden oder wenn die zusätzliche Flexibilität oder die Funktionen von ThreadPoolExecutor (die diese Klasse erweitert) erforderlich sind.

ExecutorService/ThreadPoolExecutor oder ScheduledThreadPoolExecutor ist eine offensichtliche Wahl, wenn Sie mehrere Arbeitsthreads haben.

Vorteile von ExecutorService gegenüber Timer

1. Timer kann im Gegensatz zu ExecutorService die verfügbaren CPU-Kerne nicht nutzen, insbesondere nicht bei mehreren Aufgaben, bei denen Varianten von ExecutorService wie ForkJoinPool verwendet werden
2. ExecutorService bietet eine API für die Zusammenarbeit, wenn Sie die Koordination zwischen mehreren Aufgaben benötigen. Angenommen, Sie müssen N Worker-Tasks übergeben und auf die Fertigstellung aller Tasks warten. Sie können es leicht mit invokeAll API erreichen. Wenn Sie dasselbe mit mehreren Timer Aufgaben erreichen möchten, ist dies nicht einfach.

3. ThreadPoolExecutor bietet eine bessere API für die Verwaltung des Thread-Lebenszyklus.

   Thread-Pools lösen zwei unterschiedliche Probleme: Sie bieten in der Regel eine verbesserte Leistung bei der Ausführung einer großen Anzahl von asynchronen Aufgaben, da der Aufwand für den Aufruf pro Aufgabe reduziert ist, und sie bieten eine Möglichkeit zum Binden und Verwalten der Ressourcen, einschließlich der Threads, die beim Ausführen einer Auflistung von verbraucht werden Aufgaben. Jeder ThreadPoolExecutor verwaltet auch einige grundlegende Statistiken, z. B. die Anzahl der abgeschlossenen Aufgaben

   Einige Vorteile:

   ein. Sie können den Lebenszyklus von Threads erstellen/verwalten/steuern und die Gemeinkosten für die Thread-Erstellung optimieren

   b. Sie können die Verarbeitung von Aufgaben (Work Stealing, ForkJoinPool, invokeAll) usw. steuern.

   c. Sie können den Fortschritt und den Zustand von Threads überwachen

   d. Bietet einen besseren Mechanismus zur Ausnahmebehandlung

Mein Grund, warum ich manchmal Timer gegenüber Executors.newSingleThreadScheduledExecutor () bevorzuge, ist, dass ich viel saubereren Code erhalte, wenn ich den Timer für die Ausführung in Daemon-Threads benötige.

vergleichen Sie

private final ThreadFactory threadFactory = new ThreadFactory() {
    public Thread newThread(Runnable r) {
        Thread t = new Thread(r);
        t.setDaemon(true);
        return t;
    }
};
private final ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor(threadFactory); 

mit

private final Timer timer = new Timer(true);

Ich mache das, wenn ich nicht die Robustheit eines Executorservice brauche.