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

"文件也不会刷新。"