Concurrency in Java with threads and reactive programming

Abstract

Gleichzeitig stattfindende Aktivitäten begleiten unser tägliches Leben und sind für den Menschen selbstverständlich. In der Programmierung werden solche Aktivitäten durch nebenläufige Aufgaben ausgedrückt. Zwei gängige Ansätze für den Umgang mit Gleichzeitigkeit in Java sind die Java-Threads (Plattform-Threads und virtuelle Threads) und das modernere, reaktive Programmierparadigma, das in dieser Arbeit auf der Grundlage von RxJava analysiert wird. Diese Arbeit bietet einen umfassenden Vergleich von Threads und RxJava, wobei der Schwerpunkt darauf liegt, zu verstehen, warum die reaktive Programmierung für die Bewältigung von Nebenläufigkeitsproblemen gut geeignet ist und wie sie sich grundlegend von Thread-basierten Ansätzen unterscheidet. Außerdem wird untersucht, wie sich Leistung und Speicherverbrauch zwischen den beiden Paradigmen unterscheiden. Darüber hinaus wird in dieser Arbeit der Entwicklungsaufwand untersucht, der für die Implementierung vergleichbarer Szenarien mit den beiden Ansätzen erforderlich ist.Die Methodik folgt einem strukturierten Ansatz, der mit einer umfassenden Literaturrecherche beginnt, um eine theoretische Grundlage zu schaffen. Basierend auf dieser Grundlage wird ein realistisches Szenario entworfen. Dieses Szenario wird dann sowohl mit Java Threads als auch mit RxJava implementiert. Zum Vergleich werden die wichtigsten Bewertungskennzahlen für Leistung, Speicherverbrauch und Entwicklungskomplexität definiert und gemessen. Die gesammelten Daten werden analysiert, um die Stärken und Grenzen jedes Ansatzes zu ermitteln, und es werden iterative Verfeinerungen des Szenarios vorgenommen, um die Gültigkeit und Relevanz der Ergebnisse zu verbessern.Die Ergebnisse zeigen, dass RxJava für die Verwaltung der Gleichzeitigkeit sehr effektiv ist, insbesondere bei I/O-gebundenen Aufgaben, bei denen die nicht blockierende Natur und die Wiederverwendung interner Threads eine bessere Zeitleistung bieten. Außerdem weist RxJava aufgrund seines ereignisgesteuerten Gleichzeitigkeitsmodells einen geringeren Speicherverbrauch auf. Die steilere Lernkurve der reaktiven Programmierung erfordert jedoch zusätzliche Entwicklerfähigkeiten.Virtuelle Java-Threads verbessern die zeitliche Leistung von Plattform-Threads insbesondere bei I/O-gebundenen Aufgaben. Virtuelle Threads verbrauchen viel weniger Speicher als Plattform-Threads und können daher eine gute Alternative zu RxJava sein, insbesondere für konkurrierende Szenarien mit einer geringen Anzahl von konkurrierenden Aufgaben und einer großen Anzahl von blockierenden Aufrufen. Allerdings haben virtuelle Threads im Vergleich zu Plattform-Threads keine signifikante Verbesserung der zeitlichen Leistung bei der Bearbeitung von CPU-gebundenen Aufgaben. Die Messungen zeigen vergleichbare Ergebnisse wie die für die RxJava-Implementierung durchgeführten Messungen.Diese Untersuchung kommt zu dem Schluss, dass Threads zwar nach wie vor für CPU-gebundene Aufgaben und Szenarien, die eine präzise Steuerung erfordern, von Vorteil sind, RxJava jedoch erhebliche Vorteile in Bezug auf Abstraktion, Ressourceneffizienz und die einfache Verwaltung asynchroner Aufgaben bietet, was es zu einem wertvollen Werkzeug für die moderne Softwareentwicklung macht.

Simultaneous activities accompany our everyday lives and are natural for humans. In programming such activities are expressed via concurrent tasks. Two common approaches for handling concurrency in Java are Java threads (platform threads and virtual threads) and the more modern, reactive programming paradigm analysed in this thesis on the basis of RxJava. This thesis provides a comprehensive comparison of Threads and RxJava, focusing on understanding why reactive programming is well-suited for addressing concurrent problems and how it differs fundamentally from thread-based approach. We also investigate how performance and memory usage vary between the two paradigms. Additionally, we explore the development effort required to implement comparable scenarios using each approach.The methodology follows a structured approach, beginning with a comprehensive literature review to establish theoretical foundations. Based on these foundations, a realistic scenario is designed. This scenario is then implemented using both Java Threads (platform threads and virtual threads) and RxJava. For comparison, key evaluation metrics for performance and memory consumption are defined and measured. The collected data is analyzed to identify the strengths and limitations of each approach, and iterative refinements to the scenario are performed to improve the validity and relevance of the findings.Results indicate that RxJava is highly effective for managing concurrency, particularly in I/O-bound tasks, where its non-blocking nature and reuse of internal threads provide superior time performance. Additionally, RxJava demonstrates lower memory consumption due to its event driven concurrency model. However, the steeper learning curve of reactive programming and rather complicated analysability of code require additional developer proficiency.Java virtual threads improve the time performance of platform threads especially for I/O-bound tasks. Virtual threads use much less memory than platform threads and for this reason they can be a good alternative of RxJava especially for concurrent scenarios with a low number of concurrent tasks and a big number of blocking calls. However, virtual threads do not have significant improvement of time performance while dealing with CPU-bound tasks comparing to platform threads. The measurements show comparable results with the measurements conducted for the RxJava implementation.This research concludes that while threads are still advantageous for CPU-bound tasks and scenarios requiring precise control, RxJava provides significant benefits in terms of abstraction, resource efficiency, and ease of managing asynchronous tasks, making it a valuable tool for modern software development.