PhilKa: Die Seite wurde neu angelegt: „= Reactor-Entwurfsmuster (Reactor Pattern) = Das '''Reactor-Entwurfsmuster''' ist ein Entwurfsmuster aus der Kategorie der '''Verhaltensmuster''', das häufig in '''ereignisgesteuerten''' Systemen verwendet wird – insbesondere in '''Netzwerkservern''' und '''asynchronen Anwendungen'''. Es dient dazu, mehrere gleichzeitige Ereignisse (z. B. eingehende Verbindungen, eingehende Daten oder Timer) effizient zu verarbeiten, ohne für jedes Ereignis einen ei…“

2025-10-30T11:35:18Z

Die Seite wurde neu angelegt: „= Reactor-Entwurfsmuster (Reactor Pattern) = Das '''Reactor-Entwurfsmuster''' ist ein Entwurfsmuster aus der Kategorie der '''Verhaltensmuster''', das häufig in '''ereignisgesteuerten''' Systemen verwendet wird – insbesondere in '''Netzwerkservern''' und '''asynchronen Anwendungen'''. Es dient dazu, mehrere gleichzeitige Ereignisse (z. B. eingehende Verbindungen, eingehende Daten oder Timer) effizient zu verarbeiten, ohne für jedes Ereignis einen ei…“

Neue Seite

= Reactor-Entwurfsmuster (Reactor Pattern) =

Das '''Reactor-Entwurfsmuster''' ist ein Entwurfsmuster aus der Kategorie der '''Verhaltensmuster''', das häufig in '''ereignisgesteuerten''' Systemen verwendet wird – insbesondere in '''Netzwerkservern''' und '''asynchronen Anwendungen'''.

Es dient dazu, mehrere gleichzeitige Ereignisse (z. B. eingehende Verbindungen, eingehende Daten oder Timer) effizient zu verarbeiten, ohne für jedes Ereignis einen eigenen Thread zu starten.

== Grundidee ==

Der Reactor ist eine zentrale '''Ereignisverteiler-Komponente''' (Event Demultiplexer), die auf verschiedene Eingabekanäle (z. B. Sockets) wartet.
Wenn ein Ereignis eintritt, '''delegiert''' der Reactor die Bearbeitung an die zuständige '''Event-Handler-Komponente'''.

Das Muster trennt also:
* die '''Ereigniserkennung''' (I/O oder Signale),
* die '''Ereignisverteilung''', und
* die '''Ereignisverarbeitung'''.

== Struktur ==
Typische Komponenten des Reactor-Musters:

{| class="wikitable"
! Komponente !! Aufgabe
|-
| '''Handle''' || Ein Deskriptor (z. B. Socket oder File-Handle), der Ereignisse erzeugen kann
|-
| '''Event Demultiplexer''' || Wartet auf Ereignisse mehrerer Handles (z. B. mit <code>select()</code>, <code>poll()</code> oder <code>epoll()</code>)
|-
| '''Reactor''' || Registriert Event-Handler und leitet eintreffende Ereignisse weiter
|-
| '''Event Handler''' || Implementiert die Logik, die bei einem bestimmten Ereignis ausgeführt werden soll
|-
| '''Concrete Event Handler''' || Konkrete Implementierung (z. B. ClientHandler, FileHandler)
|}

== Ablaufdiagramm ==
Typischer Kontrollfluss des Reactor-Musters:

<pre>
+---------------------+
| Reactor |
|---------------------|
| - Event-Loop |
| - Demultiplexer |
+---------+-----------+
|
v
[Event tritt auf]
|
v
+---------------------+
| Event Handler |
|---------------------|
| onRead(), onWrite()|
+---------------------+
</pre>

== Beispiel (C++) ==
Ein einfaches Beispiel, wie ein Reactor mit <code>select()</code> mehrere Sockets überwacht:

<syntaxhighlight lang="cpp">
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <iostream>
#include <vector>
#include <algorithm>

class EventHandler {
public:
virtual int getHandle() const = 0;
virtual void handleEvent() = 0;
virtual ~EventHandler() = default;
};

class ClientHandler : public EventHandler {
int sockfd;
public:
explicit ClientHandler(int fd) : sockfd(fd) {}
int getHandle() const override { return sockfd; }
void handleEvent() override {
char buffer[256];
int n = read(sockfd, buffer, sizeof(buffer) - 1);
if (n > 0) {
buffer[n] = '\0';
std::cout << "Nachricht: " << buffer << std::endl;
}
else {
std::cout << "Client getrennt.\n";
close(sockfd);
}
}
};

class Reactor {
std::vector<EventHandler*> handlers;
public:
void registerHandler(EventHandler* handler) {
handlers.push_back(handler);
}

void handleEvents() {
while (true) {
fd_set readfds;
FD_ZERO(&readfds);
int maxfd = 0;

for (auto* h : handlers) {
FD_SET(h->getHandle(), &readfds);
maxfd = std::max(maxfd, h->getHandle());
}

int ready = select(maxfd + 1, &readfds, nullptr, nullptr, nullptr);
if (ready > 0) {
for (auto* h : handlers)
if (FD_ISSET(h->getHandle(), &readfds))
h->handleEvent();
}
}
}
};
</syntaxhighlight>

Dieses Beispiel zeigt den Kernmechanismus:
Der Reactor wartet mit <code>select()</code> auf Ereignisse und ruft dann den passenden Handler auf.

== Vorteile ==
* Hohe Effizienz bei vielen gleichzeitigen Verbindungen (non-blocking I/O)
* Klare Trennung von Ereigniserkennung und -verarbeitung
* Erweiterbar um neue Ereignistypen durch neue Handler

== Nachteile ==
* Erhöhter Programmieraufwand
* Komplexere Fehlerbehandlung
* Nicht ideal für CPU-lastige Aufgaben (dafür eignet sich das [[Proactor-Entwurfsmuster]])

== Vergleich: Reactor vs. Proactor ==
{| class="wikitable"
! Merkmal !! Reactor !! Proactor
|-
| Auslöseart || Ereignis (z. B. "Daten sind verfügbar") || Abschluss (z. B. "Lesevorgang ist beendet")
|-
| Typischer Einsatz || Non-blocking I/O || Asynchronous I/O
|-
| Steuerung || Anwendung reagiert aktiv auf Ereignisse || Betriebssystem meldet fertige Operationen
|}

== Siehe auch ==
* [[Proactor-Entwurfsmuster]]
* [[Observer-Entwurfsmuster]]
* [[Event-Driven Architecture]]
* [[select() (C)]]
* [[epoll() (Linux)]]
* [[Socket (Informatik)]]

== Quellen ==
* Douglas C. Schmidt: *Reactor: An Object Behavioral Pattern for Demultiplexing and Dispatching Handles for Synchronous Events*
* POSA2 – *Pattern-Oriented Software Architecture: Patterns for Concurrent and Networked Objects*
* [https://en.wikipedia.org/wiki/Reactor_pattern Wikipedia: Reactor Pattern]
* [https://man7.org/linux/man-pages/man2/select.2.html select(2) Manpage]

Reactor-Entwurfsmuster (Reactor Pattern) - Versionsgeschichte