# 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:
# python-doc bot, 2025
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-01-03 16:35+0000\n"
"PO-Revision-Date: 2025-09-22 17:54+0000\n"
"Last-Translator: python-doc bot, 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 ":func:`sys.unraisablehook` is now used to handle unhandled exceptions."
msgstr "现在会使用 :func:`sys.unraisablehook` 来处理未处理的异常。"

#: ../../library/_thread.rst:66
msgid ""
"Simulate the effect of a :data:`signal.SIGINT` signal arriving in the main "
"thread. A thread can use this function to interrupt the main thread."
msgstr "模拟一个 :data:`signal.SIGINT` 信号到达主线程的效果。 线程可以使用这个函数来中断主线程。"

#: ../../library/_thread.rst:69
msgid ""
"If :data:`signal.SIGINT` isn't handled by Python (it was set to "
":data:`signal.SIG_DFL` or :data:`signal.SIG_IGN`), this function does "
"nothing."
msgstr ""
"如果 Python 没有处理 :data:`signal.SIGINT` (将它设为 :data:`signal.SIG_DFL` 或 "
":data:`signal.SIG_IGN`)，此函数将不做任何事。"

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

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

#: ../../library/_thread.rst:96
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:104
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:110
msgid ""
":ref:`Availability <availability>`: Windows, FreeBSD, Linux, macOS, OpenBSD,"
" NetBSD, AIX."
msgstr ""
":ref:`可用性 <availability>`: Windows, FreeBSD, Linux, macOS, OpenBSD, NetBSD, "
"AIX。"

#: ../../library/_thread.rst:116
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:131
msgid ""
":ref:`Availability <availability>`: Windows, systems with POSIX threads."
msgstr ":ref:`适用于 <availability>`: Windows，具有 POSIX 线程的系统。"

#: ../../library/_thread.rst:136
msgid ""
"The maximum value allowed for the *timeout* parameter of "
":meth:`Lock.acquire`. Specifying a timeout greater than this value will "
"raise an :exc:`OverflowError`."
msgstr ""
":meth:`Lock.acquire` 方法中 *timeout* 参数允许的最大值。传入超过这个值的 timeout 会抛出 "
":exc:`OverflowError` 异常。"

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

#: ../../library/_thread.rst:148
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:152
msgid ""
"If the integer *waitflag* argument is present, the action depends on its "
"value: if it is zero, the lock is only acquired if it can be acquired "
"immediately without waiting, while if it is nonzero, the lock is acquired "
"unconditionally as above."
msgstr ""
"如果传入了整型参数 *waitflag*，具体的行为取决于传入的值：如果是 0 "
"的话，只会在能够立刻获取到锁时才获取，不会等待，如果是非零的话，会像之前提到的一样，无条件获取锁。"

#: ../../library/_thread.rst:157
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 *waitflag* is zero."
msgstr ""
"如果传入正浮点数参数 *timeout*，相当于指定了返回之前等待得最大秒数。如果传入负的 *timeout*，相当于无限期等待。如果 "
"*waitflag* 是 0 的话，不能指定 *timeout*。"

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

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

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

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

#: ../../library/_thread.rst:180
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:183
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:193
msgid "**Caveats:**"
msgstr "**注意事项：**"

#: ../../library/_thread.rst:197
msgid ""
"Threads interact strangely with interrupts: the :exc:`KeyboardInterrupt` "
"exception will be received by an arbitrary thread.  (When the :mod:`signal` "
"module is available, interrupts always go to the main thread.)"
msgstr ""
"线程与中断奇怪地交互：:exc:`KeyboardInterrupt` 异常可能会被任意一个线程捕获。（如果 :mod:`signal` "
"模块可用的话，中断总是会进入主线程。）"

#: ../../library/_thread.rst:201
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:204
msgid ""
"It is not possible to interrupt the :meth:`acquire` method on a lock --- the"
" :exc:`KeyboardInterrupt` exception will happen after the lock has been "
"acquired."
msgstr "不可能中断锁的 :meth:`acquire` 方法 —— :exc:`KeyboardInterrupt` 一场会在锁获取到之后发生。"

#: ../../library/_thread.rst:207
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:212
msgid ""
"When the main thread exits, it does not do any of its usual cleanup (except "
"that :keyword:`try` ... :keyword:`finally` clauses are honored), and the "
"standard I/O files are not flushed."
msgstr ""
"当主线程退出时，不会进行正常的清理工作（除非使用了 :keyword:`try` ... :keyword:`finally` 语句），标准 I/O "
"文件也不会刷新。"