# German translation of the Python documentation.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

#

# Translators:

# Swen Bachmann, 2026

#

msgid ""

msgstr ""

"Project-Id-Version: Python 3.15\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-08-22 12:07+0200\n"

"PO-Revision-Date: 2026-10-15 06:00+0200\n"

"Last-Translator: python-doc bot, 2025\n"

"Language-Team: German (https://github.com/python/python-docs-de)\n"

"Language: de\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\n"

#: ../../howto/free-threading-python.rst:5

msgid "Python support for free threading"

msgstr "Unterstützung von freiem Threading in Python"

#: ../../howto/free-threading-python.rst:7

msgid ""

"Starting with the 3.13 release, CPython has support for a build of Python "

"called :term:`free threading` where the :term:`global interpreter lock` "

"(GIL) is disabled. Free-threaded execution allows for full utilization of "

"the available processing power by running threads in parallel on available "

"CPU cores. While not all software will benefit from this automatically, "

"programs designed with threading in mind will run faster on multi-core "

"hardware."

msgstr ""

"Seit der Veröffentlichung von 3.13 unterstützt CPython einen Python-Build "

"namens :term:`freies Threading <free threading>`, bei dem der :term:`Global "

"Interpreter Lock <global interpreter lock>` (GIL) abgeschaltet ist. Die "

"freie Ausführung von Threads erlaubt es, die verfügbare Rechenleistung voll "

"auszuschöpfen, indem Threads parallel auf den vorhandenen CPU-Kernen laufen. "

"Nicht jede Software profitiert davon automatisch, aber Programme, die von "

"Anfang an auf Threads ausgelegt sind, laufen auf Mehrkern-Hardware schneller."

#: ../../howto/free-threading-python.rst:14

msgid ""

"Some third-party packages, in particular ones with an :term:`extension "

"module`, may not be ready for use in a free-threaded build, and will re-"

"enable the :term:`GIL`."

msgstr ""

"Manche Pakete von Dritten, insbesondere solche mit "

"einem :term:`Erweiterungsmodul <extension module>`, sind für den Einsatz in "

"einem Free-Threaded-Build möglicherweise noch nicht bereit und schalten "

"den :term:`GIL` wieder ein."

#: ../../howto/free-threading-python.rst:18

msgid ""

"This document describes the implications of free threading for Python code. "

"See :ref:`freethreading-extensions-howto` for information on how to write C "

"extensions that support the free-threaded build."

msgstr ""

"Dieses Dokument beschreibt, was freies Threading für Python-Code bedeutet. "

"Wie du C-Erweiterungen schreibst, die den Free-Threaded-Build unterstützen, "

"steht unter :ref:`freethreading-extensions-howto`."

#: ../../howto/free-threading-python.rst:24

msgid ""

":pep:`703` – Making the Global Interpreter Lock Optional in CPython for an "

"overall description of free-threaded Python."

msgstr ""

":pep:`703` – Making the Global Interpreter Lock Optional in CPython, für "

"eine Gesamtbeschreibung von Python mit freiem Threading."

#: ../../howto/free-threading-python.rst:29

msgid "Installation"

msgstr "Installation"

#: ../../howto/free-threading-python.rst:31

msgid ""

"Starting with Python 3.13, the official macOS and Windows installers "

"optionally support installing free-threaded Python binaries. The installers "

"are available at https://www.python.org/downloads/."

msgstr ""

"Seit Python 3.13 können die offiziellen Installationsprogramme für macOS und "

"Windows auf Wunsch auch die Free-Threaded-Programmdateien von Python "

"installieren. Die Installationsprogramme findest du unter https://"

"www.python.org/downloads/."

#: ../../howto/free-threading-python.rst:35

msgid ""

"For information on other platforms, see the `Installing a Free-Threaded "

"Python <https://py-free-threading.github.io/installing-cpython/>`_, a "

"community-maintained installation guide for installing free-threaded Python."

msgstr ""

"Informationen zu anderen Plattformen findest du unter `Installing a Free-"

"Threaded Python <https://py-free-threading.github.io/installing-cpython/>`_, "

"einer von der Gemeinschaft gepflegten Anleitung zur Installation von Python "

"mit freiem Threading."

#: ../../howto/free-threading-python.rst:39

msgid ""

"When building CPython from source, the :option:`--disable-gil` configure "

"option should be used to build a free-threaded Python interpreter."

msgstr ""

"Wenn du CPython aus den Quellen baust, solltest du die configure-"

"Option :option:`--disable-gil` verwenden, um einen Python-Interpreter mit "

"freiem Threading zu bauen."

#: ../../howto/free-threading-python.rst:44

msgid "Identifying free-threaded Python"

msgstr "Python mit freiem Threading erkennen"

#: ../../howto/free-threading-python.rst:46

msgid ""

"To check if the current interpreter supports free-threading, :option:`python "

"-VV <-V>` and :data:`sys.version` contain \"free-threading build\". The "

"new :func:`sys._is_gil_enabled` function can be used to check whether the "

"GIL is actually disabled in the running process."

msgstr ""

"Um zu prüfen, ob der aktuelle Interpreter freies Threading "

"unterstützt: :option:`python -VV <-V>` und :data:`sys.version` enthalten "

"„free-threading build“. Mit der neuen Funktion :func:`sys._is_gil_enabled` "

"lässt sich prüfen, ob der GIL im laufenden Prozess tatsächlich abgeschaltet "

"ist."

#: ../../howto/free-threading-python.rst:51

msgid ""

"The ``sysconfig.get_config_var(\"Py_GIL_DISABLED\")`` configuration variable "

"can be used to determine whether the build supports free threading. If the "

"variable is set to ``1``, then the build supports free threading. This is "

"the recommended mechanism for decisions related to the build configuration."

msgstr ""

"Über die Konfigurationsvariable "

"``sysconfig.get_config_var(\"Py_GIL_DISABLED\")`` lässt sich feststellen, ob "

"der Build freies Threading unterstützt. Ist die Variable auf ``1`` gesetzt, "

"unterstützt der Build freies Threading. Das ist der empfohlene Weg für "

"Entscheidungen, die von der Build-Konfiguration abhängen."

#: ../../howto/free-threading-python.rst:58

msgid "The global interpreter lock in free-threaded Python"

msgstr "Der Global Interpreter Lock in Python mit freiem Threading"

#: ../../howto/free-threading-python.rst:60

msgid ""

"Free-threaded builds of CPython support optionally running with the GIL "

"enabled at runtime using the environment variable :envvar:`PYTHON_GIL` or "

"the command-line option :option:`-X gil`."

msgstr ""

"Free-Threaded-Builds von CPython können auf Wunsch zur Laufzeit auch mit "

"eingeschaltetem GIL laufen – über die Umgebungsvariable :envvar:`PYTHON_GIL` "

"oder die Befehlszeilenoption :option:`-X gil`."

#: ../../howto/free-threading-python.rst:64

msgid ""

"The GIL may also automatically be enabled when importing a C-API extension "

"module that is not explicitly marked as supporting free threading. A "

"warning will be printed in this case."

msgstr ""

"Der GIL kann außerdem automatisch eingeschaltet werden, wenn ein C-API-"

"Erweiterungsmodul importiert wird, das nicht ausdrücklich als „unterstützt "

"freies Threading“ gekennzeichnet ist. In diesem Fall wird eine Warnung "

"ausgegeben."

#: ../../howto/free-threading-python.rst:68

msgid ""

"In addition to individual package documentation, the following websites "

"track the status of popular packages support for free threading:"

msgstr ""

"Neben der Dokumentation der einzelnen Pakete verfolgen die folgenden "

"Webseiten, wie weit beliebte Pakete freies Threading unterstützen:"

#: ../../howto/free-threading-python.rst:71

msgid "https://py-free-threading.github.io/tracking/"

msgstr "https://py-free-threading.github.io/tracking/"

#: ../../howto/free-threading-python.rst:72

msgid "https://hugovk.github.io/free-threaded-wheels/"

msgstr "https://hugovk.github.io/free-threaded-wheels/"

#: ../../howto/free-threading-python.rst:76

msgid "Thread safety"

msgstr "Threadsicherheit"

#: ../../howto/free-threading-python.rst:78

msgid ""

"The free-threaded build of CPython aims to provide similar thread-safety "

"behavior at the Python level to the default GIL-enabled build. Built-in "

"types like :class:`dict`, :class:`list`, and :class:`set` use internal locks "

"to protect against concurrent modifications in ways that behave similarly to "

"the GIL. However, Python has not historically guaranteed specific behavior "

"for concurrent modifications to these built-in types, so this should be "

"treated as a description of the current implementation, not a guarantee of "

"current or future behavior."

msgstr ""

"Der Free-Threaded-Build von CPython will auf Python-Ebene ein ähnliches "

"Verhalten in Bezug auf Threadsicherheit bieten wie der Standard-Build mit "

"eingeschaltetem GIL. Integrierte Typen wie :class:`dict`, :class:`list` "

"und :class:`set` verwenden interne Sperren, um sich gegen gleichzeitige "

"Änderungen zu schützen, und verhalten sich dabei ähnlich wie der GIL. Python "

"hat allerdings historisch kein bestimmtes Verhalten bei gleichzeitigen "

"Änderungen an diesen integrierten Typen garantiert. Das Gesagte ist daher "

"als Beschreibung der aktuellen Implementierung zu verstehen, nicht als "

"Garantie für aktuelles oder künftiges Verhalten."

#: ../../howto/free-threading-python.rst:89

msgid ""

"It's recommended to use the :class:`threading.Lock` or other synchronization "

"primitives instead of relying on the internal locks of built-in types, when "

"possible."

msgstr ""

"Es ist empfehlenswert, wo möglich :class:`threading.Lock` oder andere "

"Synchronisationsprimitive zu verwenden, anstatt sich auf die internen "

"Sperren der integrierten Typen zu verlassen."

#: ../../howto/free-threading-python.rst:95

msgid "Known limitations"

msgstr "Bekannte Einschränkungen"

#: ../../howto/free-threading-python.rst:97

msgid ""

"This section describes known limitations of the free-threaded CPython build."

msgstr ""

"Dieser Abschnitt beschreibt bekannte Einschränkungen des Free-Threaded-"

"Builds von CPython."

#: ../../howto/free-threading-python.rst:100

msgid "Immortalization"

msgstr "Unsterblichkeit"

#: ../../howto/free-threading-python.rst:102

msgid ""

"In the free-threaded build, some objects are :term:`immortal`. Immortal "

"objects are not deallocated and have reference counts that are never "

"modified. This is done to avoid reference count contention that would "

"prevent efficient multi-threaded scaling."

msgstr ""

"Im Free-Threaded-Build sind manche Objekte :term:`unsterblich <immortal>`. "

"Unsterbliche Objekte werden nicht freigegeben, und ihre Referenzzähler "

"werden nie verändert. Damit wird ein Gedränge um die Referenzzähler "

"vermieden, das eine effiziente Skalierung über mehrere Threads verhindern "

"würde."

#: ../../howto/free-threading-python.rst:107

msgid "As of the 3.14 release, immortalization is limited to:"

msgstr ""

"Mit der Veröffentlichung von 3.14 ist die Unsterblichkeit beschränkt auf:"

#: ../../howto/free-threading-python.rst:109

msgid ""

"Code constants: numeric literals, string literals, and tuple literals "

"composed of other constants."

msgstr ""

"Codekonstanten: Zahlenliterale, Zeichenkettenliterale und Tupelliterale, die "

"aus anderen Konstanten bestehen."

#: ../../howto/free-threading-python.rst:111

msgid "Strings interned by :func:`sys.intern`."

msgstr "Zeichenketten, die mit :func:`sys.intern` interniert wurden."

#: ../../howto/free-threading-python.rst:115

msgid "Frame objects"

msgstr "Frame-Objekte"

#: ../../howto/free-threading-python.rst:117

msgid ""

"It is not safe to access :attr:`frame.f_locals` from a :ref:`frame <frame-"

"objects>` object if that frame is currently executing in another thread, and "

"doing so may crash the interpreter."

msgstr ""

"Es ist nicht sicher, von einem :ref:`Frame <frame-objects>`-Objekt aus "

"auf :attr:`frame.f_locals` zuzugreifen, wenn dieser Frame gerade in einem "

"anderen Thread ausgeführt wird. Der Interpreter kann dabei abstürzen."

#: ../../howto/free-threading-python.rst:123

msgid "Iterators"

msgstr "Iteratoren"

#: ../../howto/free-threading-python.rst:125

msgid ""

"It is generally not thread-safe to access the same iterator object from "

"multiple threads concurrently, and threads may see duplicate or missing "

"elements."

msgstr ""

"Es ist im Allgemeinen nicht threadsicher, aus mehreren Threads gleichzeitig "

"auf dasselbe Iteratorobjekt zuzugreifen. Die Threads können doppelte oder "

"fehlende Elemente sehen."

#: ../../howto/free-threading-python.rst:131

msgid "Single-threaded performance"

msgstr "Leistung bei einem einzelnen Thread"

#: ../../howto/free-threading-python.rst:133

msgid ""

"The free-threaded build has additional overhead when executing Python code "

"compared to the default GIL-enabled build. The amount of overhead depends "

"on the workload and hardware. On the pyperformance benchmark suite, the "

"average overhead ranges from about 1% on macOS aarch64 to 8% on x86-64 Linux "

"systems."

msgstr ""

"Der Free-Threaded-Build hat beim Ausführen von Python-Code einen "

"zusätzlichen Aufwand gegenüber dem Standard-Build mit eingeschaltetem GIL. "

"Wie groß dieser Aufwand ist, hängt von der Arbeitslast und der Hardware ab. "

"In der Benchmark-Sammlung pyperformance reicht der durchschnittliche Aufwand "

"von etwa 1 % auf macOS aarch64 bis zu 8 % auf x86-64-Linux-Systemen."

#: ../../howto/free-threading-python.rst:141

msgid "Behavioral changes"

msgstr "Verhaltensänderungen"

#: ../../howto/free-threading-python.rst:143

msgid ""

"This section describes CPython behavioural changes with the free-threaded "

"build."

msgstr ""

"Dieser Abschnitt beschreibt Verhaltensänderungen von CPython im Free-"

"Threaded-Build."

#: ../../howto/free-threading-python.rst:148

msgid "Context variables"

msgstr "Kontextvariablen"

#: ../../howto/free-threading-python.rst:150

msgid ""

"In the free-threaded build, the "

"flag :data:`~sys.flags.thread_inherit_context` is set to true by default "

"which causes threads created with :class:`threading.Thread` to start with a "

"copy of the :class:`~contextvars.Context()` of the caller "

"of :meth:`~threading.Thread.start`. In the default GIL-enabled build, the "

"flag defaults to false so threads start with an "

"empty :class:`~contextvars.Context()`."

msgstr ""

"Im Free-Threaded-Build ist das "

"Flag :data:`~sys.flags.thread_inherit_context` standardmäßig auf wahr "

"gesetzt. Dadurch starten Threads, die mit :class:`threading.Thread` erzeugt "

"werden, mit einer Kopie des :class:`~contextvars.Context()` des Aufrufers "

"von :meth:`~threading.Thread.start`. Im Standard-Build mit eingeschaltetem "

"GIL ist das Flag standardmäßig falsch, sodass Threads mit einem "

"leeren :class:`~contextvars.Context()` starten."

#: ../../howto/free-threading-python.rst:160

msgid "Warning filters"

msgstr "Warnungsfilter"

#: ../../howto/free-threading-python.rst:162

msgid ""

"In the free-threaded build, the "

"flag :data:`~sys.flags.context_aware_warnings` is set to true by default. "

"In the default GIL-enabled build, the flag defaults to false. If the flag "

"is true then the :class:`warnings.catch_warnings` context manager uses a "

"context variable for warning filters. If the flag is false "

"then :class:`~warnings.catch_warnings` modifies the global filters list, "

"which is not thread-safe. See the :mod:`warnings` module for more details."

msgstr ""

"Im Free-Threaded-Build ist das "

"Flag :data:`~sys.flags.context_aware_warnings` standardmäßig auf wahr "

"gesetzt. Im Standard-Build mit eingeschaltetem GIL ist das Flag "

"standardmäßig falsch. Ist das Flag wahr, verwendet der "

"Kontextmanager :class:`warnings.catch_warnings` eine Kontextvariable für die "

"Warnungsfilter. Ist das Flag falsch, "

"verändert :class:`~warnings.catch_warnings` die globale Filterliste, was "

"nicht threadsicher ist. Näheres steht beim Modul :mod:`warnings`."

#: ../../howto/free-threading-python.rst:171

msgid "Increased memory usage"

msgstr "Höherer Speicherverbrauch"

#: ../../howto/free-threading-python.rst:173

msgid ""

"The free-threaded build will typically use more memory compared to the "

"default build. There are multiple reasons for this, mostly due to design "

"decisions."

msgstr ""

"Der Free-Threaded-Build verbraucht gegenüber dem Standard-Build "

"üblicherweise mehr Speicher. Dafür gibt es mehrere Gründe, die größtenteils "

"auf Entwurfsentscheidungen zurückgehen."

#: ../../howto/free-threading-python.rst:178

msgid "All interned strings are immortal"

msgstr "Alle internierten Zeichenketten sind unsterblich"

#: ../../howto/free-threading-python.rst:180

msgid ""

"For modern Python versions (since version 2.3), interning a string (e.g. "

"with :func:`sys.intern`) does not cause it to become immortal. Instead, if "

"the last reference to that string disappears, it will be removed from the "

"interned string table. This is not the case for the free-threaded build and "

"any interned string will become immortal, surviving until interpreter "

"shutdown."

msgstr ""

"In modernen Python-Versionen (seit Version 2.3) macht das Internieren einer "

"Zeichenkette (etwa mit :func:`sys.intern`) diese nicht unsterblich. "

"Verschwindet stattdessen die letzte Referenz auf diese Zeichenkette, wird "

"sie aus der Tabelle der internierten Zeichenketten entfernt. Im Free-"

"Threaded-Build ist das nicht so: Jede internierte Zeichenkette wird "

"unsterblich und überlebt bis zum Herunterfahren des Interpreters."

#: ../../howto/free-threading-python.rst:188

msgid "Non-GC objects have a larger object header"

msgstr ""

"Objekte außerhalb der Speicherbereinigung haben einen größeren Objektkopf"

#: ../../howto/free-threading-python.rst:190

msgid ""

"The free-threaded build uses a different :c:type:`PyObject` structure. "

"Instead of having the GC related information allocated before "

"the :c:type:`PyObject` structure, like in the default build, the GC related "

"info is part of the normal object header. For example, on the AMD64 "

"platform, ``None`` uses 32 bytes on the free-threaded build vs 16 bytes for "

"the default build. GC objects (such as dicts and lists) are the same size "

"for both builds since the free-threaded build does not use additional space "

"for the GC info."

msgstr ""

"Der Free-Threaded-Build verwendet eine andere :c:type:`PyObject`-Struktur. "

"Anstatt die Informationen zur Speicherbereinigung vor der :c:type:`PyObject`-"

"Struktur anzulegen, wie im Standard-Build, sind diese Informationen Teil des "

"normalen Objektkopfs. Auf der AMD64-Plattform belegt ``None`` im Free-"

"Threaded-Build zum Beispiel 32 Bytes gegenüber 16 Bytes im Standard-Build. "

"Objekte, die der Speicherbereinigung unterliegen (etwa Dicts und Listen), "

"sind in beiden Builds gleich groß, weil der Free-Threaded-Build für die "

"Informationen zur Speicherbereinigung keinen zusätzlichen Platz braucht."

#: ../../howto/free-threading-python.rst:200

msgid "QSBR can delay freeing of memory"

msgstr "QSBR kann die Freigabe von Speicher verzögern"

#: ../../howto/free-threading-python.rst:202

msgid ""

"In order to safely implement lock-free data structures, a safe memory "

"reclamation (SMR) scheme is used, known as quiescent state-based reclamation "

"(QSBR). This means that the memory backing data structures allowing lock-"

"free access will use QSBR, which defers the free operation, rather than "

"immediately freeing the memory. Two examples of these data structures are "

"the list object and the dictionary keys object. See ``InternalDocs/"

"qsbr.md`` in the CPython source tree for more details on how QSBR is "

"implemented. Running :func:`gc.collect` should cause all memory being held "

"by QSBR to be actually freed. Note that even when QSBR frees the memory, "

"the underlying memory allocator may not immediately return that memory to "

"the OS and so the resident set size (RSS) of the process might not decrease."

msgstr ""

"Um sperrfreie Datenstrukturen sicher umzusetzen, wird ein Verfahren zur "

"sicheren Speicherrückgewinnung (safe memory reclamation, SMR) eingesetzt, "

"bekannt als quiescent state-based reclamation (QSBR). Das bedeutet, dass der "

"Speicher hinter Datenstrukturen mit sperrfreiem Zugriff QSBR verwendet, was "

"die Freigabe aufschiebt, anstatt den Speicher sofort freizugeben. Zwei "

"Beispiele für solche Datenstrukturen sind das Listenobjekt und das Objekt "

"mit den Schlüsseln eines Wörterbuchs. Näheres dazu, wie QSBR umgesetzt ist, "

"steht in ``InternalDocs/qsbr.md`` im Quellbaum von CPython. Ein Aufruf "

"von :func:`gc.collect` sollte dazu führen, dass der ganze von QSBR gehaltene "

"Speicher tatsächlich freigegeben wird. Beachte, dass die darunterliegende "

"Speicherverwaltung diesen Speicher selbst dann, wenn QSBR ihn freigibt, "

"möglicherweise nicht sofort an das Betriebssystem zurückgibt. Die Resident "

"Set Size (RSS) des Prozesses sinkt dann also nicht."

#: ../../howto/free-threading-python.rst:216

msgid "mimalloc allocator vs pymalloc"

msgstr "Die Speicherverwaltung mimalloc gegenüber pymalloc"

#: ../../howto/free-threading-python.rst:218

msgid ""

"The default build will normally use the \"pymalloc\" memory allocator for "

"small allocations (512 bytes or smaller). The free-threaded build does not "

"use pymalloc and allocates all Python objects using the \"mimalloc\" "

"allocator. The pymalloc allocator has the following properties that help "

"keep memory usage low: small per-allocated-block overhead, effective memory "

"fragmentation prevention, and quick return of free memory to the operating "

"system. The mimalloc allocator does quite well in these respects as well "

"but can have some more overhead."

msgstr ""

"Der Standard-Build verwendet für kleine Speicheranforderungen (512 Bytes "

"oder kleiner) normalerweise die Speicherverwaltung „pymalloc“. Der Free-"

"Threaded-Build verwendet pymalloc nicht und legt alle Python-Objekte mit der "

"Speicherverwaltung „mimalloc“ an. Die Speicherverwaltung pymalloc hat die "

"folgenden Eigenschaften, die den Speicherverbrauch niedrig halten: geringer "

"Aufwand je angelegtem Block, wirksame Vermeidung von Speicherfragmentierung "

"und schnelle Rückgabe freien Speichers an das Betriebssystem. Die "

"Speicherverwaltung mimalloc schlägt sich in diesen Punkten ebenfalls recht "

"gut, kann aber etwas mehr Aufwand mitbringen."

#: ../../howto/free-threading-python.rst:227

msgid ""

"In the free-threaded build, mimalloc manages memory in a number of separate "

"heaps (currently four). For example, all GC supporting objects are "

"allocated from their own heap. Using separate heaps means that free memory "

"in one heap cannot be used for an allocation that uses another heap. Also, "

"some heaps are configured to use QSBR (quiescent-state based reclamation) "

"when freeing the memory that backs up the heap (known as \"pages\" in "

"mimalloc terminology). The use of QSBR creates a delay between all memory "

"blocks for a page being freed and the memory page being released, either for "

"new allocations or back to the OS."

msgstr ""

"Im Free-Threaded-Build verwaltet mimalloc den Speicher in mehreren "

"getrennten Halden (derzeit vier). So werden zum Beispiel alle Objekte, die "

"die Speicherbereinigung unterstützen, aus ihrer eigenen Halde angelegt. "

"Getrennte Halden bedeuten, dass freier Speicher in einer Halde nicht für "

"eine Anforderung aus einer anderen Halde genutzt werden kann. Außerdem sind "

"manche Halden so eingerichtet, dass sie QSBR (quiescent-state based "

"reclamation) verwenden, wenn der Speicher freigegeben wird, der die Halde "

"unterlegt (in der Begriffswelt von mimalloc „Pages“ genannt). Durch den "

"Einsatz von QSBR entsteht eine Verzögerung zwischen der Freigabe aller "

"Speicherblöcke einer Page und der Freigabe der Speicherpage selbst – "

"entweder für neue Anforderungen oder zurück an das Betriebssystem."

#: ../../howto/free-threading-python.rst:237

msgid ""

"The mimalloc allocator also defers returning freed memory back to the OS. "

"You can reduce that delay by setting the environment variable :envvar:`!"

"MIMALLOC_PURGE_DELAY` to ``0``. Note that this will likely reduce the "

"performance of the allocator."

msgstr ""

"Auch die Speicherverwaltung mimalloc schiebt die Rückgabe freigegebenen "

"Speichers an das Betriebssystem auf. Du kannst diese Verzögerung verkürzen, "

"indem du die Umgebungsvariable :envvar:`!MIMALLOC_PURGE_DELAY` auf ``0`` "

"setzt. Beachte, dass das die Leistung der Speicherverwaltung wahrscheinlich "

"verschlechtert."

#: ../../howto/free-threading-python.rst:244

msgid "Free-threaded reference counting can cause objects to live longer"

msgstr "Referenzzählung mit freiem Threading kann Objekte länger leben lassen"

#: ../../howto/free-threading-python.rst:246

msgid ""

"In the default build, when an object's reference count reaches zero, it is "

"normally deallocated. The free-threaded build uses \"biased reference "

"counting\", with a fast-path for objects \"owned\" by the current thread and "

"a slow path for other objects. See :pep:`703` for additional details. Any "

"time an object's reference count ends up in a \"queued\" state, deallocation "

"can be deferred. The queued state is cleared from the \"eval breaker\" "

"section of the bytecode evaluator."

msgstr ""

"Im Standard-Build wird ein Objekt normalerweise freigegeben, sobald sein "

"Referenzzähler null erreicht. Der Free-Threaded-Build verwendet „biased "

"reference counting“ mit einem schnellen Weg für Objekte, die dem aktuellen "

"Thread „gehören“, und einem langsamen Weg für andere Objekte. Weitere "

"Details stehen in :pep:`703`. Immer wenn der Referenzzähler eines Objekts in "

"einem „eingereihten“ Zustand landet, kann die Freigabe aufgeschoben werden. "

"Der eingereihte Zustand wird im Abschnitt „eval breaker“ des Bytecode-"

"Auswerters aufgelöst."

#: ../../howto/free-threading-python.rst:254

msgid ""

"The free-threaded build also allows a different mode of reference counting, "

"known as \"deferred reference counting\". This mode is enabled by setting a "

"flag on a per-object basis. Deferred reference counting is enabled for the "

"following types:"

msgstr ""

"Der Free-Threaded-Build erlaubt außerdem eine andere Art der "

"Referenzzählung, bekannt als „deferred reference counting“ (aufgeschobene "

"Referenzzählung). Diese Betriebsart wird pro Objekt über ein Flag "

"eingeschaltet. Für die folgenden Typen ist die aufgeschobene Referenzzählung "

"eingeschaltet:"

#: ../../howto/free-threading-python.rst:259

msgid "module objects"

msgstr "Modulobjekte"

#: ../../howto/free-threading-python.rst:260

msgid "module top-level functions"

msgstr "Funktionen auf der obersten Ebene eines Moduls"

#: ../../howto/free-threading-python.rst:261

msgid "class methods defined in the class scope"

msgstr "Klassenmethoden, die im Klassenbereich definiert sind"

#: ../../howto/free-threading-python.rst:262

msgid "descriptor objects"

msgstr "Deskriptor-Objekte"

#: ../../howto/free-threading-python.rst:263

msgid "thread-local objects, created by :class:`threading.local`"

msgstr "thread-lokale Objekte, erzeugt mit :class:`threading.local`"

#: ../../howto/free-threading-python.rst:265

msgid ""

"When deferred reference counting is enabled, references from Python function "

"stacks are not added to the reference count. This scheme reduces the "

"overhead of reference counting, especially for objects used from multiple "

"threads. Because the stack references are not counted, objects with deferred "

"reference counting are not immediately freed when their internal reference "

"count goes to zero. Instead, they are examined by the next GC run and, if "

"no stack references to them are found, they are freed. This means these "

"objects are freed by the GC and not when their reference count goes to zero, "

"as is typical."

msgstr ""

"Ist die aufgeschobene Referenzzählung eingeschaltet, werden Referenzen von "

"den Stapeln von Python-Funktionen nicht in den Referenzzähler aufgenommen. "

"Dieses Verfahren verringert den Aufwand der Referenzzählung, besonders für "

"Objekte, die aus mehreren Threads verwendet werden. Weil die Referenzen auf "

"dem Stapel nicht gezählt werden, werden Objekte mit aufgeschobener "

"Referenzzählung nicht sofort freigegeben, wenn ihr interner Referenzzähler "

"null erreicht. Sie werden stattdessen beim nächsten Lauf der "

"Speicherbereinigung untersucht und freigegeben, wenn sich keine Referenzen "

"auf dem Stapel mehr auf sie finden. Das heißt, dass diese Objekte von der "

"Speicherbereinigung freigegeben werden und nicht, wie üblich, sobald ihr "

"Referenzzähler null erreicht."

#: ../../howto/free-threading-python.rst:276

msgid "Per-thread reference counting can delay freeing objects"

msgstr "Referenzzählung pro Thread kann die Freigabe von Objekten verzögern"

#: ../../howto/free-threading-python.rst:278

msgid ""

"To avoid contention on the reference count fields of frequently shared "

"objects, the free-threaded build also uses \"per-thread reference counting\" "

"for a few selected object types. Rather than updating a single shared "

"reference count, each thread maintains its own local reference count array, "

"indexed by a unique id assigned to the object. The true reference count is "

"only computed by summing the per-thread counts when the object's local count "

"drops to zero. Per-thread reference counting is currently used for:"

msgstr ""

"Um ein Gedränge um die Referenzzählerfelder häufig gemeinsam genutzter "

"Objekte zu vermeiden, verwendet der Free-Threaded-Build für einige "

"ausgewählte Objekttypen außerdem eine „Referenzzählung pro Thread“. Anstatt "

"einen einzigen gemeinsamen Referenzzähler zu aktualisieren, führt jeder "

"Thread sein eigenes lokales Feld von Referenzzählern, indiziert über eine "

"dem Objekt zugewiesene eindeutige Kennung. Der tatsächliche Referenzzähler "

"wird erst dann berechnet, wenn der lokale Zähler des Objekts null erreicht – "

"durch Summieren der Zähler aller Threads. Die Referenzzählung pro Thread "

"wird derzeit verwendet für:"

#: ../../howto/free-threading-python.rst:286

msgid "heap type objects (classes created in Python)"

msgstr "Haldentypobjekte (in Python erzeugte Klassen)"

#: ../../howto/free-threading-python.rst:287

msgid "code objects"

msgstr "Codeobjekte"

#: ../../howto/free-threading-python.rst:288

msgid "the ``__dict__`` of module objects"

msgstr "das ``__dict__`` von Modulobjekten"

#: ../../howto/free-threading-python.rst:290

msgid ""

"Because the per-thread counts must be merged back to the object before it "

"can be deallocated, objects using per-thread reference counting are "

"typically freed later than they would be in the default build. In "

"particular, such an object is usually not freed until the thread that "

"referenced it reaches a safe point (for example, in the \"eval breaker\" "

"section of the bytecode evaluator) or exits. Running :func:`gc.collect` "

"will merge the per-thread counts and allow these objects to be freed."

msgstr ""

"Weil die Zähler aller Threads vor der Freigabe des Objekts wieder "

"zusammengeführt werden müssen, werden Objekte mit Referenzzählung pro Thread "

"üblicherweise später freigegeben als im Standard-Build. Insbesondere wird "

"ein solches Objekt meist erst dann freigegeben, wenn der Thread, der es "

"referenziert hat, einen sicheren Punkt erreicht (zum Beispiel im Abschnitt "

"„eval breaker“ des Bytecode-Auswerters) oder sich beendet. Ein Aufruf "

"von :func:`gc.collect` führt die Zähler aller Threads zusammen und erlaubt "

"die Freigabe dieser Objekte."