← C++

C++ · 12 / 24

Datenrennen mit ThreadSanitizer untersuchen

Du vergleichst ungeschützte gemeinsame Änderungen mit einer synchronisierten Variante.

  • Groß
  • Anspruchsvoll
  • 90 min

Voraussetzungen: Hintergrundarbeit, Performance und Desktop-Pakete, Speicherfehler mit AddressSanitizer finden

In diesem Tutorial
  1. Den Vertrag festlegen
  2. Werkzeuge und Build trennen
  3. Beobachtbare Erwartungen prüfen
  4. Eine falsche Änderung erkennen
  5. Die Übung getrennt ausführen
  6. Grenzen des Nachweises einordnen
  7. Übung und Lösung
  8. Projektbezug und Quellen

Lernpaket herunterladen

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.

ThreadSanitizer benötigt eine unterstützte Linux-Umgebung. Bei einem Adressraumkonflikt versucht verify.py einen einzelnen Prozess mit setarch ohne ASLR zu starten. Systemweite Einstellungen werden nicht verändert.

Geprüft am 21.10.2026 unter Linux x86_64. Der Prüflauf verlangt einen echten data-race-Befund und kontrolliert danach den korrigierten Zähler. Einige Linux-Umgebungen benötigen den dokumentierten Prozessstart mit setarch. Ein nicht startender Sanitizer gilt nicht als bestanden.

Ein passender Endwert beweist keine Freiheit von Datenrennen. Zwei Threads können dieselbe Speicherstelle ohne ausreichende Synchronisation ändern und gelegentlich trotzdem das erwartete Ergebnis liefern. ThreadSanitizer beobachtet Speicherzugriffe. Der Mutex schützt die gesamte Änderung.

Paketinhalt und einzelne Dateien

01Den Vertrag festlegen

Zwei Threads schreiben im Negativbeispiel auf denselben Zähler ohne Synchronisation. ThreadSanitizer erkennt den Datenkonflikt. Die Korrektur verwendet atomare Zugriffe. Atomarität eines Zählers macht einen mehrteiligen Geschäftsablauf noch nicht atomar.

main.cpp · cppDatei öffnen
#include <iostream>
#include <mutex>
#include <stdexcept>
#include <thread>
int main() {
  int count = 0;
  std::mutex mutex;
  auto increment = [&] {
    for (int i = 0; i < 10000; ++i) {
      std::lock_guard guard(mutex);
      ++count;
    }
  };
  std::jthread a(increment), b(increment);
  a.join();
  b.join();
  if (count != 20000)
    throw std::runtime_error("Lost update");
  std::cout << "count=20000\n";
}

Starten / prüfen

python3 verify.py

02Werkzeuge und Build trennen

Lege alle Dateien in einen neuen Ordner. Lies die Compileroptionen und führe verify.py aus. Der Rückgabecode eines fehlgeschlagenen Befehls muss bis zum Aufrufer erhalten bleiben.

verify.py · pyDatei öffnen
import os, subprocess, sys

flags = [
    "g++",
    "-std=c++20",
    "-g",
    "-O1",
    "-fno-omit-frame-pointer",
    "-fsanitize=thread",
    "-pthread",
    "-no-pie",
]
for source, name in [("broken.cpp", "broken"), ("main.cpp", "fixed")]:
    subprocess.run(flags + [source, "-o", name], check=True)
    env = dict(
        os.environ, ASAN_OPTIONS="detect_leaks=0", TSAN_OPTIONS="halt_on_error=1"
    )
    result = subprocess.run(["./" + name], capture_output=True, text=True, env=env)
    if "unexpected memory mapping" in result.stderr:
        import platform

        result = subprocess.run(
            ["setarch", platform.machine(), "-R", "./" + name],
            capture_output=True,
            text=True,
            env=env,
        )
    if name == "broken":
        expected = "data race"
        if not result.returncode or expected not in result.stderr:
            print(result.stderr)
            sys.exit(
                "Sanitizer did not demonstrate the expected defect. Check host support."
            )
        print("Expected sanitizer diagnosis:", expected)
    else:
        if result.returncode:
            print(result.stderr)
            sys.exit(result.returncode)
        print(result.stdout.strip())

03Beobachtbare Erwartungen prüfen

Der Prüflauf verlangt einen echten data-race-Befund und kontrolliert danach den korrigierten Zähler. Einige Linux-Umgebungen benötigen den dokumentierten Prozessstart mit setarch. Ein nicht startender Sanitizer gilt nicht als bestanden.

CMakeLists.txt · cmakeDatei öffnen
cmake_minimum_required(VERSION 3.20)
project(learning LANGUAGES CXX)
set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
add_executable(lesson main.cpp)
enable_testing()
add_test(NAME behaviour COMMAND lesson)
Erwartetes Ergebnis

Der Prüflauf verlangt einen echten data-race-Befund und kontrolliert danach den korrigierten Zähler. Einige Linux-Umgebungen benötigen den dokumentierten Prozessstart mit setarch. Ein nicht startender Sanitizer gilt nicht als bestanden.

04Eine falsche Änderung erkennen

Ändere eine geprüfte Bedingung oder das erwartete Ergebnis. Der Prüfbefehl muss nun fehlschlagen. Stelle danach den Ausgangszustand wieder her. Ein grüner Prozess allein erklärt noch nicht, welche Eigenschaft geschützt wird.

05Die Übung getrennt ausführen

Ersetze den Mutex für diesen einzelnen Zähler durch std::atomic<int>.

06Grenzen des Nachweises einordnen

Relaxed ist hier ausreichend, weil der Zähler keine anderen Daten veröffentlicht und join auf beide Threads wartet. Mehrere zusammengehörige Felder benötigen einen gemeinsamen Synchronisationsvertrag.

Erwartetes Ergebnis

Der Prüflauf endet erfolgreich. Die im Beispiel benannten Bedingungen werden geprüft.

Deine Übung

Ersetze den Mutex für diesen einzelnen Zähler durch std::atomic<int>.

Lösung mit Erklärung anzeigen

Relaxed ist hier ausreichend, weil der Zähler keine anderen Daten veröffentlicht und join auf beide Threads wartet. Mehrere zusammengehörige Felder benötigen einen gemeinsamen Synchronisationsvertrag.

solution.cpp · cppDatei öffnen
#include <atomic>
#include <stdexcept>
#include <thread>
int main() {
  std::atomic<int> count{0};
  auto increment = [&] {
    for (int i = 0; i < 10000; ++i)
      count.fetch_add(1, std::memory_order_relaxed);
  };
  std::jthread a(increment), b(increment);
  a.join();
  b.join();
  if (count.load() != 20000)
    throw std::runtime_error("Lost update");
}

Projektbezug und Quellen

Das eigenständige Lernprojekt vertieft ein Thema aus diesem Technologiebereich. Die Projektverweise zeigen einen festgehaltenen Quellstand als Architekturkontext. Sie sind kein Beleg dafür, dass jede hier neu eingeführte Bibliothek oder Funktion bereits in dieser App verwendet wird.