functional and commented

analysis_model.h

@@ -0,0 +1,75 @@
+#pragma once
+#include <mutex>
+#include <condition_variable>
+
+/**
+ * Implementiert das Reader-Writer Problem mit:
+ * - Mehrere gleichzeitige Leser
+ * - Exklusiver Zugriff für Schreiber
+ * - Verhindert Writer-Starvation
+ */
+class AnalysisModel {
+    int value = 0;              // Das geteilte Analysemodell (vereinfacht)
+    int reader_count = 0;       // Zählt aktive Leser
+    
+    // Synchronisationsprimitive
+    std::mutex model_mutex;     // Schützt Schreibzugriffe (exklusiv)
+    std::mutex count_mutex;     // Schützt Leserzähler
+    std::condition_variable no_writer; // Garantiert Fairness
+
+public:
+    /**
+     * Lesender Zugriff
+     * @return Aktueller Wert des Modells
+     * 
+     * Funktionsweise:
+     * 1. Sperrt count_mutex und inkrementiert reader_count
+     * 2. Erster Leser sperrt model_mutex (blockiert Writer)
+     * 3. Entsperrt count_mutex während des Lesens
+     * 4. Liest Wert
+     * 5. Sperrt count_mutex zum Dekrementieren
+     * 6. Letzter Leser entsperrt model_mutex und benachrichtigt Writer
+     */
+    int read() {
+        std::unique_lock<std::mutex> count_lock(count_mutex);
+        reader_count++;
+        
+        // Erster Leser sperrt für Writer
+        if(reader_count == 1) {
+            model_mutex.lock();
+        }
+        count_lock.unlock();
+
+        // Kritischer Abschnitt (Lesen, kann parallel erfolgen)
+        int result = value;
+
+        count_lock.lock();
+        reader_count--;
+        // Letzter Leser gibt für Writer frei
+        if(reader_count == 0) {
+            model_mutex.unlock();
+            no_writer.notify_one();
+        }
+        
+        return result;
+    }
+
+    /**
+     * Schreibender Zugriff
+     * @param new_value Neuer Wert für das Modell
+     * 
+     * Funktionsweise:
+     * 1. Sperrt model_mutex (exklusiver Zugriff)
+     * 2. Schreibt neuen Wert
+     * 3. Wartet bis alle Leser fertig sind (Starvation Prevention)
+     */
+    void write(int new_value) {
+        std::unique_lock<std::mutex> lock(model_mutex);
+        value = new_value;
+        
+        // Verhindert Writer-Starvation
+        no_writer.wait(lock, [this]() { 
+            return reader_count == 0; 
+        });
+    }
+};