# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

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

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

#, fuzzy

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-10-12 03:18+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Language-Team: German (https://app.transifex.com/python-doc/teams/5390/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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

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

msgid "Installation"

msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

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

msgid "Identifying free-threaded Python"

msgstr ""

#: ../../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 ""

#: ../../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 ""

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

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

msgstr ""

#: ../../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 ""

#: ../../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 ""

#: ../../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 ""

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

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

msgstr ""

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

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

msgstr ""

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

msgid "Thread safety"

msgstr ""

#: ../../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. See :ref:`threadsafety` for the guarantees provided by built-in "

"types."

msgstr ""

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

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 ""

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

msgid "Known limitations"

msgstr ""

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

msgid ""

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

msgstr ""

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

msgid "Immortalization"

msgstr ""

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

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 ""

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

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

msgstr ""

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

msgid ""

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

"composed of other constants."

msgstr ""

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

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

msgstr ""

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

msgid "Frame objects"

msgstr ""

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

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 ""

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

msgid "Iterators"

msgstr ""

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

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 ""

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

msgid "Single-threaded performance"

msgstr ""

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

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 ""

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

msgid "Behavioral changes"

msgstr ""

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

msgid ""

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

"build."

msgstr ""

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

msgid "Context variables"

msgstr ""

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

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 ""

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

msgid "Warning filters"

msgstr ""

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

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 ""

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

msgid "Increased memory usage"

msgstr ""

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

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 ""

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

msgid "All interned strings are immortal"

msgstr ""

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

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 ""

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

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

msgstr ""

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

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 ""

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

msgid "QSBR can delay freeing of memory"

msgstr ""

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

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 ""

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

msgid "mimalloc allocator vs pymalloc"

msgstr ""

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

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 ""

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

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 ""

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

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 ""

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

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

msgstr ""

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

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 ""

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

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 ""

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

msgid "module objects"

msgstr ""

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

msgid "module top-level functions"

msgstr ""

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

msgid "class methods defined in the class scope"

msgstr ""

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

msgid "descriptor objects"

msgstr ""

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

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

msgstr ""

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

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 ""

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

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

msgstr ""

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

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 ""

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

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

msgstr ""

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

msgid "code objects"

msgstr ""

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

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

msgstr ""

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

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 ""