python-docs-zh-cn/howto/free-threading-python.po at 3.15 · python/python-docs-zh-cn

500 lines (433 loc) · 23.3 KB
# 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.
# Translators:
# python-doc bot, 2025
# 99 <wh2099@pm.me>, 2026
# Freesand Leo <yuqinju@163.com>, 2026
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-05-31 15:14+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2026\n"
"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: zh_CN\n"
"Plural-Forms: nplurals=1; plural=0;\n"
#: ../../howto/free-threading-python.rst:5
msgid "Python support for free threading"
msgstr "Python 对自由线程的支持"
#: ../../howto/free-threading-python.rst:7
"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."
"从 3.13 发布版开始，CPython 支持 :term:`free threading` 的 Python 构建，其禁用 :term:`global"
" interpreter lock` (GIL)。自由线程化的执行允许在可用的 CPU 核心上并行运行线程，充分利用可用的处理能力。 "
"尽管并非所有软件都能自动地从中受益，但是考虑到线程设计的程序在多核硬件上运行速度会更快。"
#: ../../howto/free-threading-python.rst:14
"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`."
"某些第三方包，特别是带有 :term:`extension module` 的包，可能尚不适用于自由线程构建版，并将重新启用 :term:`GIL`。"
#: ../../howto/free-threading-python.rst:18
"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."
"本文档描述了自由线程对 Python 代码的影响。请参阅 :ref:`freethreading-extensions-howto` "
"了解如何编写支持自由线程构建的 C 扩展。"
#: ../../howto/free-threading-python.rst:24
":pep:`703` – Making the Global Interpreter Lock Optional in CPython for an "
"overall description of free-threaded Python."
msgstr ":pep:`703` —— 查阅《在 CPython 中使全局解释器锁成为可选项》以了解对自由线程 Python 的整体描述。"
#: ../../howto/free-threading-python.rst:29
msgid "Installation"
msgstr "安装"
#: ../../howto/free-threading-python.rst:31
"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/."
"从 Python 3.13 开始，官方 macOS 和 Windows 安装器提供了对可选安装自由线程 Python 二进制文件的支持。安装器可在 "
"https://www.python.org/downloads/ 获取。"
#: ../../howto/free-threading-python.rst:35
"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."
"有关其他平台的信息，请参阅 `Installing a Free-Threaded Python <https://py-free-"
"threading.github.io/installing-cpython/>`_，这是一份由社区维护的针对安装自由线程版 Python 的安装指南。"
#: ../../howto/free-threading-python.rst:39
"When building CPython from source, the :option:`--disable-gil` configure "
"option should be used to build a free-threaded Python interpreter."
msgstr "当从源码构建 CPython 时，应使用 :option:`--disable-gil` 配置选项以构建自由线程 Python 解释器。"
#: ../../howto/free-threading-python.rst:44
msgid "Identifying free-threaded Python"
msgstr "识别自由线程 Python"
#: ../../howto/free-threading-python.rst:46
"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."
"要判断当前解释器是否支持自由线程，可检查 :option:`python -VV <-V>` 和 :data:`sys.version` 是否包含 "
"\"free-threading build\"。新的 :func:`sys._is_gil_enabled` 函数可用于检查在运行进程中 GIL "
#: ../../howto/free-threading-python.rst:51
"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."
"``sysconfig.get_config_var(\"Py_GIL_DISABLED\")`` 配置变量可用于确定构建是否支持自由线程。 "
"如果该变量设置为 ``1``，则构建支持自由线程。这是与构建配置相关的决策的推荐机制。"
#: ../../howto/free-threading-python.rst:58
msgid "The global interpreter lock in free-threaded Python"
msgstr "自由线程版 Python 中的全局解释器锁"
#: ../../howto/free-threading-python.rst:60
"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`."
"CPython 的自由线程构建版支持在运行时使用环境变量 :envvar:`PYTHON_GIL` 或命令行选项 :option:`-X gil` "
"选择性地启用 GIL。"
#: ../../howto/free-threading-python.rst:64
"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 "GIL 也可能在导入未显式标记为支持自由线程模式的 C-API 扩展模块时被自动启用。在这种情况下将会打印一条警告。"
#: ../../howto/free-threading-python.rst:68
"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 "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 "线程安全"
#: ../../howto/free-threading-python.rst:78
"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."
"自由线程构建的 CPython 旨在 Python 层级提供与默认全局解释器锁启用构建相似的线程安全行为。内置类型（如 :class:`dict`、 "
":class:`list` 和 :class:`set` 等）使用内部上锁来防止并发修改，其行为方式与全局解释器锁相似。但是，Python "
"历来不对这些内置类型的并发修改提供特定的行为保证，因此这应被视为对当前实现的描述，而不是对当前或未来行为的保证。"
#: ../../howto/free-threading-python.rst:89
"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 "建议尽可能使用 :class:`threading.Lock` 或其他同步原语，而不是依赖内置类型的内部锁。"
#: ../../howto/free-threading-python.rst:95
msgid "Known limitations"
msgstr "已知的限制"
#: ../../howto/free-threading-python.rst:97
"This section describes known limitations of the free-threaded CPython build."
msgstr "本节介绍自由线程 CPython 构建的已知限制。"
#: ../../howto/free-threading-python.rst:100
msgid "Immortalization"
msgstr "永生化"
#: ../../howto/free-threading-python.rst:102
"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."
"在自由线程构建中，某些对象属于 :term:`immortal` 对象。永生对象不会被释放且具有永远不会被修改的引用计数。 "
"这样做是为了避免发生可能妨碍高效的多线程伸缩调整的引用计数争夺问题。"
#: ../../howto/free-threading-python.rst:107
msgid "As of the 3.14 release, immortalization is limited to:"
msgstr "对于 3.14 发布版，永生对象只限于："
#: ../../howto/free-threading-python.rst:109
"Code constants: numeric literals, string literals, and tuple literals "
"composed of other constants."
msgstr "代码常量：数字字面值，字符串字面值，以及由其他常量组成的元组字面值。"
#: ../../howto/free-threading-python.rst:111
msgid "Strings interned by :func:`sys.intern`."
msgstr "由 :func:`sys.intern` 所内化的字符串。"
#: ../../howto/free-threading-python.rst:115
msgid "Frame objects"
msgstr "帧对象"
#: ../../howto/free-threading-python.rst:117
"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."
"从一个 :ref:`帧对象 <frame-objects>` 访问 :attr:`frame.f_locals` "
"是不安全的，如果该帧目前是在另一个线程中执行的话，这样做可能会导致解释器崩溃。"
#: ../../howto/free-threading-python.rst:123
msgid "Iterators"
msgstr "迭代器"
#: ../../howto/free-threading-python.rst:125
"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:131
msgid "Single-threaded performance"
msgstr "单线程性能"
#: ../../howto/free-threading-python.rst:133
"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."
"自由线程构建在执行 Python 代码时相比默认启用 GIL 的构建会有额外的开销。具体的开销取决于工作量和硬件环境。在 pyperformance "
"基准测试套件中，平均开销增幅在 macOS aarch64 上约为 1% 而在 x86-64 Linux 系统上约为 8%。"
#: ../../howto/free-threading-python.rst:141
msgid "Behavioral changes"
msgstr "行为的变化"
#: ../../howto/free-threading-python.rst:143
"This section describes CPython behavioural changes with the free-threaded "
msgstr "本节描述 CPython 在自由线程构建时的行为变化。"
#: ../../howto/free-threading-python.rst:148
msgid "Context variables"
msgstr "上下文变量"
#: ../../howto/free-threading-python.rst:150
"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()`."
"在自由线程构建中，:data:`~sys.flags.thread_inherit_context` 标志默认设置为 true，这会导致使用 "
":class:`threading.Thread` 创建的线程以 :meth:`~threading.Thread.start` 的调用程序的 "
":class:`~contextvars.Context()` 的副本启动。在默认启用 GIL 的构建中，该标志默认为 false，因此线程以空 "
":class:`~contextvars.Context()` 启动。"
#: ../../howto/free-threading-python.rst:160
msgid "Warning filters"
msgstr "警告过滤器"
#: ../../howto/free-threading-python.rst:162
"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."
"在自由线程构建中，:data:`~sys.flags.context_aware_warnings` 标志默认设置为 true。在默认启用 GIL "
"的构建中，该标志默认设置为 false。如果该标志为 true，则 :class:`warnings.catch_warnings` "
"上下文管理器使用上下文变量用于警告过滤器。如果该标志为 false，则 :class:`~warnings.catch_warnings` "
"修改全局过滤器列表，这不是线程安全的。详情请参阅 :mod:`warnings` 模块。"
#: ../../howto/free-threading-python.rst:171
msgid "Increased memory usage"
msgstr "增加的内存使用"
#: ../../howto/free-threading-python.rst:173
"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:178
msgid "All interned strings are immortal"
msgstr "所有内生字符串都是永生对象"
#: ../../howto/free-threading-python.rst:180
"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."
"对于现代的 Python 版本（从 2.3 版开始），内生字符串 (例如通过 :func:`sys.intern`) 不会使它成为永生对象。 "
"作为替代，如果对某字符串的最后一次引用消失，它将从内生字符串表中移除。  "
"对于自由线程构建版来说则并非如此而是任何内生字符串都将成为永生对象，会保持存活直到解释器关闭。"
#: ../../howto/free-threading-python.rst:188
msgid "Non-GC objects have a larger object header"
msgstr "非 GC 对象具有更大的对象标头"
#: ../../howto/free-threading-python.rst:190
"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."
#: ../../howto/free-threading-python.rst:200
msgid "QSBR can delay freeing of memory"
#: ../../howto/free-threading-python.rst:202
"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."
#: ../../howto/free-threading-python.rst:216
msgid "mimalloc allocator vs pymalloc"
#: ../../howto/free-threading-python.rst:218
"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."
#: ../../howto/free-threading-python.rst:227
"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."
#: ../../howto/free-threading-python.rst:237
"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."
#: ../../howto/free-threading-python.rst:244
msgid "Free-threaded reference counting can cause objects to live longer"
#: ../../howto/free-threading-python.rst:246
"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."
#: ../../howto/free-threading-python.rst:254
"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:"
#: ../../howto/free-threading-python.rst:259
msgid "module objects"
#: ../../howto/free-threading-python.rst:260
msgid "module top-level functions"
#: ../../howto/free-threading-python.rst:261
msgid "class methods defined in the class scope"
#: ../../howto/free-threading-python.rst:262
msgid "descriptor objects"
#: ../../howto/free-threading-python.rst:263
msgid "thread-local objects, created by :class:`threading.local`"
#: ../../howto/free-threading-python.rst:265
"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."
#: ../../howto/free-threading-python.rst:276
msgid "Per-thread reference counting can delay freeing objects"
#: ../../howto/free-threading-python.rst:278
"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:"
#: ../../howto/free-threading-python.rst:286
msgid "heap type objects (classes created in Python)"
#: ../../howto/free-threading-python.rst:287
msgid "code objects"
#: ../../howto/free-threading-python.rst:288
msgid "the ``__dict__`` of module objects"
msgstr "模块对象的 ``__dict__``"
#: ../../howto/free-threading-python.rst:290
"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."
"由于对象的每线程计数必须在释放前合并回对象，使用每线程引用计数的对象通常会比在默认构建中更晚被释放。 "
"具体而言，这样的对象往往要等到引用它的线程处于安全点位（例如，在字节码求值器的 \"eval breaker\" 节中）或退出时才会被释放。 运行 "
":func:`gc.collect` 将合并每线程计数并允许这些对象被释放。"
Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Uh oh!

FilesExpand file tree

free-threading-python.po

Latest commit

History

free-threading-python.po

File metadata and controls
