{"id":350,"date":"2024-04-20T20:24:08","date_gmt":"2024-04-20T19:24:08","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=350"},"modified":"2024-06-01T20:29:35","modified_gmt":"2024-06-01T19:29:35","slug":"asynchrone-jobs-in-java-unit-tests-ohne-thread-sleep-testen","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=350","title":{"rendered":"Asynchrone Jobs in Java-Unit-Tests ohne Thread.sleep() testen"},"content":{"rendered":"\n

Das Testen von asynchronen Jobs in Java kann eine Herausforderung darstellen, insbesondere wenn diese Jobs \u00fcber einen ExecutorService<\/code> ausgef\u00fchrt werden. In diesem Artikel werden wir uns darauf konzentrieren, wie man solche Jobs testen kann, ohne Thread.sleep()<\/code> mit einer fixen Wartezeit zu verwenden. Wir werden auch die Probleme beleuchten, die Thread.sleep()<\/code> mit sich bringt und warum andere L\u00f6sungen vorzuziehen sind.<\/p>\n\n\n\n

Probleme mit Thread.sleep()<\/code><\/h2>\n\n\n\n

Thread.sleep()<\/code> wird oft in Tests verwendet, um eine bestimmte Zeitspanne zu warten, bis ein asynchroner Job abgeschlossen ist. Dies hat jedoch mehrere Nachteile:<\/p>\n\n\n\n

    \n
  1. Unzuverl\u00e4ssigkeit<\/strong>: Die Dauer, die ein asynchroner Job ben\u00f6tigt, um abgeschlossen zu werden, kann variieren, abh\u00e4ngig von der Systemlast und anderen Faktoren. Eine fixe Wartezeit kann entweder zu kurz sein (und der Test schl\u00e4gt fehl) oder zu lang (und der Test dauert unn\u00f6tig lange).<\/li>\n\n\n\n
  2. Effizienz<\/strong>: L\u00e4ngere Wartezeiten machen Tests langsam, was die Entwicklungszeit erh\u00f6ht und die Effizienz mindert.<\/li>\n\n\n\n
  3. Ressourcenverbrauch<\/strong>: Thread.sleep()<\/code> blockiert den Test-Thread und verbraucht somit Ressourcen unn\u00f6tig.<\/li>\n\n\n\n
  4. Fehlende Synchronisation<\/strong>: Thread.sleep()<\/code> synchronisiert den Test nicht wirklich mit dem Ende des asynchronen Jobs, sondern wartet lediglich eine vordefinierte Zeit ab. Das Ergebnis kann somit inkonsistent sein.<\/li>\n<\/ol>\n\n\n\n

    Bessere Ans\u00e4tze zum Testen von asynchronen Jobs<\/h2>\n\n\n\n

    1. Nutzung von Future<\/code> und ExecutorService<\/code><\/h3>\n\n\n\n

    Eine g\u00e4ngige Methode ist die Nutzung von Future<\/code>-Objekten, die von einem ExecutorService<\/code> zur\u00fcckgegeben werden. Ein Future<\/code> erm\u00f6glicht es, auf das Ergebnis eines asynchronen Jobs zu warten.<\/p>\n\n\n\n

    Beispiel:<\/p>\n\n\n

    import<\/span> java.util.concurrent.*;\n\npublic class<\/span> AsyncJobTest<\/span> <\/span>{\n\n    private ExecutorService executorService;\n\n    @Before\n    public void<\/span> setUp() {\n        executorService = Executors.newSingleThreadExecutor();\n    }\n\n    @After\n    public void<\/span> tearDown() {\n        executorService.shutdown();\n    }\n\n    @Test\n    public void<\/span> testAsyncJob() throws ExecutionException, InterruptedException {\n        Callable<String<\/span>> job = () -> {\n            \/\/ Simulierte lange Operation<\/span>\n            Thread.sleep(1000<\/span>);\n            return<\/span> \"Job Result\"<\/span>;\n        };\n\n        Future<String<\/span>> future = executorService.submit(job);\n\n        \/\/ Warten auf das Ergebnis<\/span>\n        String<\/span> result = future.get();  \/\/ Dies blockiert, bis der Job abgeschlossen ist<\/span>\n\n        assertEquals(\"Job Result\"<\/span>, result);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    2. Nutzung von CountDownLatch<\/code><\/h3>\n\n\n\n
    CountDownLatch<\/code> ist eine Synchronisationshilfe, die verwendet werden kann, um einen oder mehrere Threads warten zu lassen, bis eine Reihe von Operationen abgeschlossen sind.<\/p>\n\n\n\n
    Beispiel:<\/p>\n\n\n
    import<\/span> java.util.concurrent.*;\nimport<\/span> static<\/span> org.junit.Assert.*;\nimport<\/span> org.junit.*;\n\npublic class<\/span> AsyncJobTest<\/span> <\/span>{\n\n    private ExecutorService executorService;\n\n    @Before\n    public void<\/span> setUp() {\n        executorService = Executors.newSingleThreadExecutor();\n    }\n\n    @After\n    public void<\/span> tearDown() {\n        executorService.shutdown();\n    }\n\n    @Test\n    public void<\/span> testAsyncJobWithCountDownLatch() throws InterruptedException {\n        CountDownLatch latch = new<\/span> CountDownLatch(1<\/span>);\n        AtomicReference<String<\/span>> result = new<\/span> AtomicReference<>();\n\n        Runnable job = () -> {\n            try<\/span> {\n                \/\/ Simulierte lange Operation<\/span>\n                Thread.sleep(1000<\/span>);\n                result.set(\"Job Result\"<\/span>);\n            } catch<\/span> (InterruptedException e) {\n                Thread.currentThread().interrupt();\n            } finally<\/span> {\n                latch.countDown();\n            }\n        };\n\n        executorService.submit(job);\n\n        \/\/ Warten bis der Latch auf null gez\u00e4hlt wurde<\/span>\n        latch.await();  \n\n        assertEquals(\"Job Result\"<\/span>, result.get());\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    3. Nutzung von CompletableFuture<\/code><\/h3>\n\n\n\n
    CompletableFuture<\/code> ist eine erweiterte Implementierung des Future<\/code>-Interfaces und bietet viele M\u00f6glichkeiten, asynchrone Operationen effizient zu handhaben.<\/p>\n\n\n\n
    Beispiel:<\/p>\n\n\n
    import<\/span> java.util.concurrent.*;\nimport<\/span> static<\/span> org.junit.Assert.*;\nimport<\/span> org.junit.*;\n\npublic class<\/span> AsyncJobTest<\/span> <\/span>{\n\n    @Test\n    public void<\/span> testAsyncJobWithCompletableFuture() throws ExecutionException, InterruptedException {\n        CompletableFuture<String<\/span>> future = CompletableFuture.supplyAsync(() -> {\n            try<\/span> {\n                \/\/ Simulierte lange Operation<\/span>\n                Thread.sleep(1000<\/span>);\n            } catch<\/span> (InterruptedException e) {\n                Thread.currentThread().interrupt();\n            }\n            return<\/span> \"Job Result\"<\/span>;\n        });\n\n        \/\/ Warten auf das Ergebnis<\/span>\n        String<\/span> result = future.get();  \n\n        assertEquals(\"Job Result\"<\/span>, result);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    4. Nutzung von Mockito und ArgumentCaptor<\/h3>\n\n\n\n
    Wenn es darum geht, zu pr\u00fcfen, ob ein asynchroner Job korrekt aufgerufen wird, kann Mockito zusammen mit ArgumentCaptor<\/code> verwendet werden.<\/p>\n\n\n\n
    Beispiel:<\/p>\n\n\n
    import<\/span> static<\/span> org.mockito.Mockito.*;\nimport<\/span> static<\/span> org.junit.Assert.*;\nimport<\/span> org.junit.*;\nimport<\/span> org.mockito.ArgumentCaptor;\n\nimport<\/span> java.util.concurrent.ExecutorService;\n\npublic class<\/span> AsyncJobTest<\/span> <\/span>{\n\n    private ExecutorService executorService;\n    private MyService myService;\n\n    @Before\n    public void<\/span> setUp() {\n        executorService = mock(ExecutorService.class);\n        myService = new<\/span> MyService(executorService);\n    }\n\n    @Test\n    public void<\/span> testAsyncJobWithMockito() {\n        ArgumentCaptor<Runnable> captor = ArgumentCaptor.forClass(Runnable.class);\n\n        myService.runAsyncJob();\n\n        verify(executorService).submit(captor.capture());\n        Runnable capturedRunnable = captor.getValue();\n\n        \/\/ Simuliere die Ausf\u00fchrung des Jobs<\/span>\n        capturedRunnable.run();\n\n        assertEquals(\"Job Result\"<\/span>, myService.getResult());\n    }\n\n    \/\/ Beispielservice, der einen asynchronen Job ausf\u00fchrt<\/span>\n    static<\/span> class<\/span> MyService<\/span> <\/span>{\n        private final ExecutorService executorService;\n        private String<\/span> result;\n\n        MyService(ExecutorService executorService) {\n            this<\/span>.executorService = executorService;\n        }\n\n        void<\/span> runAsyncJob() {\n            executorService.submit(() -> {\n                \/\/ Simulierte lange Operation<\/span>\n                try<\/span> {\n                    Thread.sleep(1000<\/span>);\n                } catch<\/span> (InterruptedException e) {\n                    Thread.currentThread().interrupt();\n                }\n                result = \"Job Result\"<\/span>;\n            });\n        }\n\n        String<\/span> getResult() {\n            return<\/span> result;\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    Fazit<\/h2>\n\n\n\n
    Das Testen von asynchronen Jobs ohne Thread.sleep()<\/code> bietet zahlreiche Vorteile. Es erh\u00f6ht die Zuverl\u00e4ssigkeit und Effizienz der Tests und verringert den Ressourcenverbrauch. Durch die Nutzung von Future<\/code>, CountDownLatch<\/code>, CompletableFuture<\/code> oder Mockito kann man sicherstellen, dass die Tests pr\u00e4zise und schnell sind. Jeder dieser Ans\u00e4tze hat seine eigenen Vorteile und kann je nach spezifischen Anforderungen des Tests verwendet werden. Die Wahl des richtigen Ansatzes h\u00e4ngt von den spezifischen Anforderungen und dem Kontext der Anwendung ab.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Das Testen von asynchronen Jobs in Java kann eine Herausforderung darstellen, insbesondere wenn diese Jobs \u00fcber einen ExecutorService ausgef\u00fchrt werden. In diesem Artikel werden wir uns darauf konzentrieren, wie man solche Jobs testen kann, ohne Thread.sleep() mit einer fixen Wartezeit zu verwenden. Wir werden auch die Probleme beleuchten, die Thread.sleep() mit sich bringt und warum […]<\/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-350","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\/350","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=350"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/350\/revisions"}],"predecessor-version":[{"id":351,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/350\/revisions\/351"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=350"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=350"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=350"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}