# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-07-25 16:03+0000\n"
"PO-Revision-Date: 2025-07-18 19:57+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\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"

#: ../../library/_thread.rst:2
msgid ":mod:`!_thread` --- Low-level threading API"
msgstr ":mod:`!_thread` --- 低层级多线程 API"

#: ../../library/_thread.rst:15
msgid ""
"This module provides low-level primitives for working with multiple threads "
"(also called :dfn:`light-weight processes` or :dfn:`tasks`) --- multiple "
"threads of control sharing their global data space.  For synchronization, "
"simple locks (also called :dfn:`mutexes` or :dfn:`binary semaphores`) are "
"provided. The :mod:`threading` module provides an easier to use and higher-"
"level threading API built on top of this module."
msgstr ""
"该模块提供了操作多个线程（也被称为 :dfn:`轻量级进程` 或 :dfn:`任务`）的底层原语 —— "
"多个控制线程共享全局数据空间。为了处理同步问题，也提供了简单的锁机制（也称为 :dfn:`互斥锁` 或 "
":dfn:`二进制信号`）。:mod:`threading` 模块基于该模块提供了更易用的高级多线程 API。"

#: ../../library/_thread.rst:26
msgid "This module used to be optional, it is now always available."
msgstr "这个模块曾经为可选项，但现在总是可用。"

#: ../../library/_thread.rst:29
msgid "This module defines the following constants and functions:"
msgstr "这个模块定义了以下常量和函数："

#: ../../library/_thread.rst:33
msgid "Raised on thread-specific errors."
msgstr "发生线程相关错误时抛出。"

#: ../../library/_thread.rst:35
msgid "This is now a synonym of the built-in :exc:`RuntimeError`."
msgstr "现在是内建异常 :exc:`RuntimeError` 的别名。"

#: ../../library/_thread.rst:41
msgid "This is the type of lock objects."
msgstr "锁对象的类型。"

#: ../../library/_thread.rst:46
msgid ""
"Start a new thread and return its identifier.  The thread executes the "
"function *function* with the argument list *args* (which must be a tuple). "
"The optional *kwargs* argument specifies a dictionary of keyword arguments."
msgstr ""
"开启一个新线程并返回其标识。 线程执行函数 *function* 并附带参数列表 *args* (必须是元组)。 可选的 *kwargs* "
"参数指定一个关键字参数字典。"

#: ../../library/_thread.rst:50
msgid "When the function returns, the thread silently exits."
msgstr "当函数返回时，线程会静默地退出。"

#: ../../library/_thread.rst:52
msgid ""
"When the function terminates with an unhandled exception, "
":func:`sys.unraisablehook` is called to handle the exception. The *object* "
"attribute of the hook argument is *function*. By default, a stack trace is "
"printed and then the thread exits (but other threads continue to run)."
msgstr ""
"当函数因某个未处理异常而终结时，:func:`sys.unraisablehook` 会被调用以处理异常。 钩子参数的 *object* 属性为 "
"*function*。 在默认情况下，会打印堆栈回溯然后该线程将退出（但其他线程会继续运行）。"

#: ../../library/_thread.rst:57
msgid ""
"When the function raises a :exc:`SystemExit` exception, it is silently "
"ignored."
msgstr "当函数引发 :exc:`SystemExit` 异常时，它会被静默地忽略。"

#: ../../library/_thread.rst:60
msgid ""
"Raises an :ref:`auditing event <auditing>` ``_thread.start_new_thread`` with"
" arguments ``function``, ``args``, ``kwargs``."
msgstr ""
"引发一个 :ref:`审计事件 <auditing>` ``_thread.start_new_thread`` 并附带参数 ``function``,"
" ``args``, ``kwargs``。"

#: ../../library/_thread.rst:62
msgid ":func:`sys.unraisablehook` is now used to handle unhandled exceptions."
msgstr "现在会使用 :func:`sys.unraisablehook` 来处理未处理的异常。"

#: ../../library/_thread.rst:68
msgid ""
"Simulate the effect of a signal arriving in the main thread. A thread can "
"use this function to interrupt the main thread, though there is no guarantee"
" that the interruption will happen immediately."
msgstr "模拟一个信号到达主线程的效果。 线程可使用此函数来打断主线程，虽然并不保证打断将立即发生。"

#: ../../library/_thread.rst:72
msgid ""
"If given, *signum* is the number of the signal to simulate. If *signum* is "
"not given, :const:`signal.SIGINT` is simulated."
msgstr ""
"如果给出 *signum*，则表示要模拟的信号的编号。 如果未给出 *signum*，则将模拟 :const:`signal.SIGINT`。"

#: ../../library/_thread.rst:75
msgid ""
"If the given signal isn't handled by Python (it was set to "
":const:`signal.SIG_DFL` or :const:`signal.SIG_IGN`), this function does "
"nothing."
msgstr ""
"如果给出的信号未被 Python 处理 (它被设为 :const:`signal.SIG_DFL` 或 "
":const:`signal.SIG_IGN`)，则此函数将不做任何操作。"

#: ../../library/_thread.rst:79
msgid "The *signum* argument is added to customize the signal number."
msgstr "添加了 *signum* 参数来定制信号的编号。"

#: ../../library/_thread.rst:83
msgid ""
"This does not emit the corresponding signal but schedules a call to the "
"associated handler (if it exists). If you want to truly emit the signal, use"
" :func:`signal.raise_signal`."
msgstr ""
"这并不会发出对应的信号而是将一个调用排入关联处理器的计划任务（如果句柄存在的话）。 如果你想要真的发出信号，请使用 "
":func:`signal.raise_signal`。"

#: ../../library/_thread.rst:90
msgid ""
"Raise the :exc:`SystemExit` exception.  When not caught, this will cause the"
" thread to exit silently."
msgstr "抛出 :exc:`SystemExit` 异常。如果没有捕获的话，这个异常会使线程退出。"

#: ../../library/_thread.rst:104
msgid ""
"Return a new lock object.  Methods of locks are described below.  The lock "
"is initially unlocked."
msgstr "返回一个新的锁对象。锁中的方法在后面描述。初始情况下锁处于解锁状态。"

#: ../../library/_thread.rst:110
msgid ""
"Return the 'thread identifier' of the current thread.  This is a nonzero "
"integer.  Its value has no direct meaning; it is intended as a magic cookie "
"to be used e.g. to index a dictionary of thread-specific data.  Thread "
"identifiers may be recycled when a thread exits and another thread is "
"created."
msgstr ""
"返回当前线程的 “线程标识符”。它是一个非零的整数。它的值没有直接含义，主要是用作 magic "
"cookie，比如作为含有线程相关数据的字典的索引。线程标识符可能会在线程退出，新线程创建时被复用。"

#: ../../library/_thread.rst:118
msgid ""
"Return the native integral Thread ID of the current thread assigned by the "
"kernel. This is a non-negative integer. Its value may be used to uniquely "
"identify this particular thread system-wide (until the thread terminates, "
"after which the value may be recycled by the OS)."
msgstr ""
"返回内核分配给当前线程的原生集成线程 ID。 这是一个非负整数。 它的值可被用来在整个系统中唯一地标识这个特定线程（直到线程终结，在那之后该值可能会被 "
"OS 回收再利用）。"

#: ../../library/_thread.rst:123 ../../library/_thread.rst:145
msgid "Availability"
msgstr "Availability"

#: ../../library/_thread.rst:130
msgid ""
"Return the thread stack size used when creating new threads.  The optional "
"*size* argument specifies the stack size to be used for subsequently created"
" threads, and must be 0 (use platform or configured default) or a positive "
"integer value of at least 32,768 (32 KiB). If *size* is not specified, 0 is "
"used.  If changing the thread stack size is unsupported, a "
":exc:`RuntimeError` is raised.  If the specified stack size is invalid, a "
":exc:`ValueError` is raised and the stack size is unmodified.  32 KiB is "
"currently the minimum supported stack size value to guarantee sufficient "
"stack space for the interpreter itself.  Note that some platforms may have "
"particular restrictions on values for the stack size, such as requiring a "
"minimum stack size > 32 KiB or requiring allocation in multiples of the "
"system memory page size - platform documentation should be referred to for "
"more information (4 KiB pages are common; using multiples of 4096 for the "
"stack size is the suggested approach in the absence of more specific "
"information)."
msgstr ""
"返回创建线程时使用的堆栈大小。可选参数 *size* "
"指定之后新建的线程的堆栈大小，而且一定要是0（根据平台或者默认配置）或者最小是32,768(32KiB)的一个正整数。如果 *size* "
"没有指定，默认是0。如果不支持改变线程堆栈大小，会抛出 :exc:`RuntimeError` 错误。如果指定的堆栈大小不合法，会抛出 "
":exc:`ValueError` "
"错误并且不会修改堆栈大小。32KiB是当前最小的能保证解释器有足够堆栈空间的堆栈大小。需要注意的是部分平台对于堆栈大小会有特定的限制，例如要求大于32KiB的堆栈大小或者需要根据系统内存页面的整数倍进行分配"
" - 应当查阅平台文档有关详细信息（4KiB页面比较普遍，在没有更具体信息的情况下，建议的方法是使用4096的倍数作为堆栈大小）。"

#: ../../library/_thread.rst:147
msgid "Unix platforms with POSIX threads support."
msgstr "带有 POSIX 线程支持的 Unix 平台。"

#: ../../library/_thread.rst:152
msgid ""
"The maximum value allowed for the *timeout* parameter of :meth:`Lock.acquire"
" <threading.Lock.acquire>`. Specifying a timeout greater than this value "
"will raise an :exc:`OverflowError`."
msgstr ""
":meth:`Lock.acquire <threading.Lock.acquire>` 的 *timeout* 形参所允许的最大值。 指定大于该值的"
" timeout 将引发 :exc:`OverflowError`。"

#: ../../library/_thread.rst:159
msgid "Lock objects have the following methods:"
msgstr "锁对象有以下方法："

#: ../../library/_thread.rst:164
msgid ""
"Without any optional argument, this method acquires the lock "
"unconditionally, if necessary waiting until it is released by another thread"
" (only one thread at a time can acquire a lock --- that's their reason for "
"existence)."
msgstr "没有任何可选参数时，该方法无条件申请获得锁，有必要的话会等待其他线程释放锁（同时只有一个线程能获得锁 —— 这正是锁存在的原因）。"

#: ../../library/_thread.rst:168
msgid ""
"If the *blocking* argument is present, the action depends on its value: if "
"it is false, the lock is only acquired if it can be acquired immediately "
"without waiting, while if it is true, the lock is acquired unconditionally "
"as above."
msgstr ""
"如果提供了 *blocking* "
"参数，具体的行为将取决于它的值：如果它为假值，则只在能够立即获取到锁而无需等待时才会获取，而如果它为真值，则会与上面一样无条件地获取锁。"

#: ../../library/_thread.rst:173
msgid ""
"If the floating-point *timeout* argument is present and positive, it "
"specifies the maximum wait time in seconds before returning.  A negative "
"*timeout* argument specifies an unbounded wait.  You cannot specify a "
"*timeout* if *blocking* is false."
msgstr ""
"如果提供了浮点数形式的 *timeout* 参数且为正值，它将指明在返回之前的最大等待秒数。 负的 *timeout* 参数表示无限期的等待。 如果 "
"*blocking* 为假值则你不能指定 *timeout*。"

#: ../../library/_thread.rst:178
msgid ""
"The return value is ``True`` if the lock is acquired successfully, ``False``"
" if not."
msgstr "如果成功获取到所会返回 ``True``，否则返回 ``False``。"

#: ../../library/_thread.rst:181
msgid "The *timeout* parameter is new."
msgstr "新的 *timeout* 形参。"

#: ../../library/_thread.rst:184
msgid "Lock acquires can now be interrupted by signals on POSIX."
msgstr "现在获取锁的操作可以被 POSIX 信号中断。"

#: ../../library/_thread.rst:190
msgid ""
"Releases the lock.  The lock must have been acquired earlier, but not "
"necessarily by the same thread."
msgstr "释放锁。锁必须已经被获取过，但不一定是同一个线程获取的。"

#: ../../library/_thread.rst:196
msgid ""
"Return the status of the lock: ``True`` if it has been acquired by some "
"thread, ``False`` if not."
msgstr "返回锁的状态：如果已被某个线程获取，返回 ``True``，否则返回 ``False``。"

#: ../../library/_thread.rst:199
msgid ""
"In addition to these methods, lock objects can also be used via the "
":keyword:`with` statement, e.g.::"
msgstr "除了这些方法之外，锁对象也可以通过 :keyword:`with` 语句使用，例如："

#: ../../library/_thread.rst:202
msgid ""
"import _thread\n"
"\n"
"a_lock = _thread.allocate_lock()\n"
"\n"
"with a_lock:\n"
"    print(\"a_lock is locked while this executes\")"
msgstr ""
"import _thread\n"
"\n"
"a_lock = _thread.allocate_lock()\n"
"\n"
"with a_lock:\n"
"    print(\"在执行这段代码时，a_lock 已被锁定\")"

#: ../../library/_thread.rst:209
msgid "**Caveats:**"
msgstr "**注意事项：**"

#: ../../library/_thread.rst:213
msgid ""
"Interrupts always go to the main thread (the :exc:`KeyboardInterrupt` "
"exception will be received by that thread.)"
msgstr "中断总是会到主线程 (:exc:`KeyboardInterrupt` 异常将由该线程接收。)"

#: ../../library/_thread.rst:216
msgid ""
"Calling :func:`sys.exit` or raising the :exc:`SystemExit` exception is "
"equivalent to calling :func:`_thread.exit`."
msgstr ""
"调用 :func:`sys.exit` 或是抛出 :exc:`SystemExit` 异常等效于调用 :func:`_thread.exit`。"

#: ../../library/_thread.rst:219
msgid ""
"It is platform-dependent whether the :meth:`~threading.Lock.acquire` method "
"on a lock can be interrupted (so that the :exc:`KeyboardInterrupt` exception"
" will happen immediately, rather than only after the lock has been acquired "
"or the operation has timed out). It can be interrupted on POSIX, but not on "
"Windows."
msgstr ""
"一个锁的 :meth:`~threading.Lock.acquire` 方法是否可被中断（这样 :exc:`KeyboardInterrupt` "
"异常将立即发生，而不是要等到获取锁或者操作超时）取决于具体的平台。 它在 POSIX 上可被中断，但在 Windows 上则不可以。"

#: ../../library/_thread.rst:225
msgid ""
"When the main thread exits, it is system defined whether the other threads "
"survive.  On most systems, they are killed without executing :keyword:`try` "
"... :keyword:`finally` clauses or executing object destructors."
msgstr ""
"当主线程退出时，由系统决定其他线程是否存活。在大多数系统中，这些线程会直接被杀掉，不会执行 :keyword:`try` ... "
":keyword:`finally` 语句，也不会执行对象析构函数。"

#: ../../library/_thread.rst:7
msgid "light-weight processes"
msgstr "轻量级进程"

#: ../../library/_thread.rst:7
msgid "processes, light-weight"
msgstr "进程，轻量级"

#: ../../library/_thread.rst:7
msgid "binary semaphores"
msgstr "二元信号量"

#: ../../library/_thread.rst:7
msgid "semaphores, binary"
msgstr "信号量，二元"

#: ../../library/_thread.rst:22
msgid "pthreads"
msgstr "pthreads"

#: ../../library/_thread.rst:22
msgid "threads"
msgstr "threads"

#: ../../library/_thread.rst:22
msgid "POSIX"
msgstr "POSIX"

#: ../../library/_thread.rst:211
msgid "module"
msgstr "module"

#: ../../library/_thread.rst:211
msgid "signal"
msgstr "signal"