Einrichtung und Prüfstand
GCC mit C++20 und CMake ab 3.25. Zusätzlich Python 3 für den gemeinsamen Prüfstart. Entpacke das Lernpaket in einen neuen Ordner und führe dort python3 run_checks.py aus. Das Skript kopiert die enthaltenen Dateien in einen temporären Lernordner. Dort prüft es zuerst das Beispiel und danach die mitgelieferte Lösung. Die Ausgangsdateien bleiben erhalten. Benötigte Pakete werden beim ersten Lauf aus dem Netz geladen.
Geprüft am 21.10.2026 unter Linux x86_64. Der echte Simulationsdienst wird gestartet und gestoppt. Die Lösung wiederholt Pause, Einzelschritt und Stop zwanzigmal. Windows-Auslieferung bleibt ungeprüft.
Ein Fenster muss während der Berechnung weiter auf Eingaben reagieren. Die fertige App verwendet deshalb einen Hintergrunddienst. Threads teilen sich den Speicher desselben Prozesses. Das macht die Übergabe von Zuständen möglich, verlangt aber eine klare Regel für gleichzeitigen Zugriff. Ein Mutex schützt hier Simulation und Zustandskopien.
std::jthread unterstützt einen geordneten Stopp über stop_token. Ein Stoppwunsch beendet Arbeit nicht magisch. Der Worker muss ihn beobachten und seine Wartestelle muss aufwachen können. Diese Lektion benutzt den echten SimulationService. Das Beispiel prüft zunächst Einzelschritte und lässt den restlichen Auftrag anschließend im Hintergrund abschließen.
Paketinhalt und einzelne Dateien
- main.cpp
- CMakeLists.txt
- vendor/factory-forge/src/application/simulation_service.cpp
- vendor/factory-forge/include/factory/application/simulation_service.h
- vendor/factory-forge/include/factory/core/simulation.h
- vendor/factory-forge/include/factory/core/project.h
- vendor/factory-forge/src/core/simulation.cpp
- vendor/factory-forge/include/factory/core/pathfinder.h
- vendor/factory-forge/src/core/puzzles.cpp
- vendor/factory-forge/include/factory/core/puzzles.h
- vendor/factory-forge/src/core/pathfinder.cpp
- vendor/factory-forge/src/core/project.cpp
- vendor/factory-forge/SOURCE.txt
- vendor/factory-forge/LICENSE
- solution/main.cpp
- run_checks.py
01Das Beispiel und seine Abhängigkeiten bauen
Entpacke das Lernpaket. Die benötigten FactoryForge-Dateien liegen unter vendor und stammen aus dem verlinkten festen Quellstand. cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug und cmake --build build bauen das eigenständige Beispiel. Das vollständige Projekt-ZIP ist für diese Prüfung nicht zusätzlich nötig.
cmake_minimum_required(VERSION 3.25)
project(ThreadLesson LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
get_filename_component(FACTORYFORGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/vendor/factory-forge" ABSOLUTE CACHE)
find_package(Threads REQUIRED)
add_executable(lesson main.cpp
"${FACTORYFORGE_SOURCE_DIR}/src/core/project.cpp"
"${FACTORYFORGE_SOURCE_DIR}/src/core/pathfinder.cpp"
"${FACTORYFORGE_SOURCE_DIR}/src/core/puzzles.cpp"
"${FACTORYFORGE_SOURCE_DIR}/src/core/simulation.cpp"
"${FACTORYFORGE_SOURCE_DIR}/src/application/simulation_service.cpp")
target_include_directories(lesson PRIVATE "${FACTORYFORGE_SOURCE_DIR}/include")
target_link_libraries(lesson PRIVATE Threads::Threads)
02Pause und Einzelschritt überprüfen
start erhält eine Musterlösung und false als Startzustand. Der Dienst besitzt eine Simulation, führt aber noch keine automatischen Schritte aus. Zwanzig Aufrufe von stepOnce ergeben exakt zwanzig logische Ticks. Das ist eine überprüfbare fachliche Aussage und hängt nicht davon ab, wie schnell der Rechner die Schleife ausführt.
#include "factory/application/simulation_service.h"
#include "factory/core/puzzles.h"
#include <chrono>
#include <iostream>
#include <thread>
int main() {
factory::SimulationService service;
service.start(factory::makePuzzle(0, true), false);
for (int i = 0; i < 20; ++i)
service.stepOnce();
std::cout << "manual_ticks=" << service.snapshot().tick << '\n';
service.setSpeed(4);
service.setPlaying(true);
const auto deadline =
std::chrono::steady_clock::now() + std::chrono::seconds(10);
while (service.snapshot().outcome == factory::Outcome::Running &&
std::chrono::steady_clock::now() < deadline)
std::this_thread::sleep_for(std::chrono::milliseconds(5));
const auto snapshot = service.snapshot();
service.stop();
std::cout << "delivered=" << snapshot.delivered << '\n';
std::cout << std::boolalpha << "stopped=" << !service.active() << '\n';
return snapshot.outcome == factory::Outcome::Won ? 0 : 1;
}
Starten / prüfen
cmake -S . -B build -G Ninja -DFACTORYFORGE_SOURCE_DIR=/path/to/factory-forge
cmake --build build
./build/lessonmanual_ticks=20
03Hintergrundlauf und Zustandskopien lesen
setSpeed(4) und setPlaying(true) starten die automatische Fortsetzung. snapshot liefert einen geschützten Wert. Der Aufrufer darf diese Kopie lesen, ohne in die laufenden Fahrzeugdaten zu schreiben. Die kurze Wartezeit im Lernprogramm verhindert eine aktive Dauerschleife. Die zusätzliche Frist verhindert, dass ein fehlerhaftes Beispiel unbegrenzt wartet.
04Den Dienst geordnet stoppen
stop fordert den Stopp an, weckt die Bedingungsvariable und wartet auf das Ende des Threads. Erst anschließend wird die Simulation freigegeben. join darf nicht unter einem Mutex laufen, den der Worker noch zum Beenden benötigt. Starte das Beispiel und prüfe neben den Ticks auch Lieferung und Lebensdauer.
manual_ticks=20 delivered=3 stopped=true
05Performance mit einem konkreten Szenario messen
Baue die App im Release-Modus und starte factoryforge-cli --benchmark 50. Der Bericht enthält Szenario, Anzahl, Lieferungen, mittlere und maximale Schrittzeit. Die mitgelieferte Messung schließt Darstellung und Echtzeit-Warten aus. Vergleiche denselben Build und denselben Rechner. Eine einzelne schnelle Demo beweist keine garantierte Leistung für beliebige Karten.
06Die Prüfung nachvollziehen
Der echte Simulationsdienst wird gestartet und gestoppt. Die Lösung wiederholt Pause, Einzelschritt und Stop zwanzigmal. Windows-Auslieferung bleibt ungeprüft. Starte python3 run_checks.py aus dem entpackten Paket. Vergleiche die Test-Erwartungen mit der Übung, bevor du die Lösung öffnest.
Beispiel und automatisierte Lösung bestehen. Die genannten manuellen Prüfungen bleiben getrennt.
07Ein Paket auf der Zielplattform prüfen
Das Linux-Paket enthält App, CLI, Qt-Laufzeit, Puzzle-Dateien und Lizenztexte. Der Launcher setzt relative Bibliothekspfade. Der Windows-Helfer verwendet windeployqt und die vorbereitete native Build-Matrix. Ein kompiliertes Programm ist noch kein geprüftes Paket. Starte die gebündelte App und den gebündelten Konsolenlauf. Der Windows-Nachweis bleibt bis zu einer echten Windows-Prüfung offen.
Deine Übung
Starte den Dienst mehrmals, pausiere, führe einen Schritt aus und stoppe ihn. Vergleiche außerdem einen Debug- und einen Release-Benchmark, ohne daraus einen allgemeinen Geschwindigkeitsfaktor abzuleiten.
Lösung mit Erklärung anzeigen
Jeder neue Lauf beginnt beim Ausgangsaufbau. In Pause verändert sich die Tickzahl ohne Einzelschritt nicht. stop beendet den Worker und active ist danach falsch. Der vorhandene Anwendungstest wiederholt diesen Ablauf zwanzigmal. Performance-Vergleiche werden mit Build-Typ, Hardware und Szenario dokumentiert. Sie erklären eine Beobachtung und ersetzen keine Prüfung auf der Zielplattform.
#include "factory/application/simulation_service.h"
#include "factory/core/puzzles.h"
#include <cassert>
#include <chrono>
#include <iostream>
#include <thread>
int main() {
factory::SimulationService service;
for (int run = 0; run < 20; ++run) {
service.start(factory::makePuzzle(0, true), false);
assert(service.snapshot().tick == 0);
service.stepOnce();
const auto paused = service.snapshot().tick;
std::this_thread::sleep_for(std::chrono::milliseconds(20));
assert(service.snapshot().tick == paused);
service.stop();
assert(!service.active());
}
service.start(factory::makePuzzle(0, true), false);
for (int i = 0; i < 20; ++i)
service.stepOnce();
std::cout << "manual_ticks=" << service.snapshot().tick << '\n';
service.setSpeed(4);
service.setPlaying(true);
const auto deadline =
std::chrono::steady_clock::now() + std::chrono::seconds(10);
while (service.snapshot().outcome == factory::Outcome::Running &&
std::chrono::steady_clock::now() < deadline)
std::this_thread::sleep_for(std::chrono::milliseconds(5));
const auto snapshot = service.snapshot();
service.stop();
std::cout << "delivered=" << snapshot.delivered << '\n';
std::cout << std::boolalpha << "stopped=" << !service.active() << '\n';
return snapshot.outcome == factory::Outcome::Won ? 0 : 1;
}
Projektbezug und Quellen
Die ersten sechs Beispiele sind eigenständige Lernprogramme. Lektionen 7 bis 9 nutzen den vollständigen FactoryForge-Quellstand. Quellcode, Übungen und überprüfte Vereinfachungen sind getrennt beschrieben. Die Projektseite bietet ein Quellcode-ZIP, solange das GitHub-Repository noch nicht veröffentlicht ist.