# Copyright (C) 2001 Python Software Foundation

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

#

# Translators:

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2025-09-08 15:25+0800\n"

"PO-Revision-Date: 2015-12-09 17:51+0000\n"

"Last-Translator: Liang-Bo Wang <[email protected]>\n"

"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"

"tw)\n"

"Language: zh_TW\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\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: `任務`）一起工作"

"的低階原語 --- 多個控制執行緒分享其全域資料空間。為了處理同步問題，也提供"

"了簡單的鎖 (lock) 機制（也稱為: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 ""

"開始一個新的執行緒並回傳其識別字 (identifier) 。該執行緒執行帶有引數列表 "

"*args*\\ （必須是一個 tuple（元組））的函式 *function*。可選的 *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 ""

"回傳由核心 (kernel) 分配的目前執行緒的原生整數執行緒 ID。這是一個非負整數。它"

"的值可用於在整個系統中唯一標識此特定執行緒（直到執行緒終止後，該值可能被操作"

"系統重新使用）。"

#: ../../library/_thread.rst:123 ../../library/_thread.rst:148

msgid "Availability"

msgstr "可用性"

#: ../../library/_thread.rst:127

msgid "Added support for GNU/kFreeBSD."

msgstr "新增了對 GNU/kFreeBSD 的支援。"

#: ../../library/_thread.rst:133

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

"KiB）的正整數值。如果未指定 *size*，則使用 0。如果不支援更改執行緒堆疊大小，"

"則會引發 :exc:`RuntimeError` 錯誤。如果指定的堆疊大小無效，則會引"

"發 :exc:`ValueError` 錯誤，並且堆疊大小不會被修改。目前，32 KiB 是保證直譯器"

"本身具有足夠堆疊空間所支援的最小堆疊大小值。請注意，某些平台對於堆疊大小的值"

"可能有特定的限制，例如要求最小堆疊大小 > 32 KiB，或要求按系統記憶體頁面大小的"

"倍數進行分配。應參考平台文件以取得更多訊息（4 KiB 頁面是比較普遍的；在缺乏更"

"具體訊息的情況下，建議使用 4096 的倍數作為堆疊大小）。"

#: ../../library/_thread.rst:150

msgid "Unix platforms with POSIX threads support."

msgstr "Unix 平台上支援 POSIX 執行緒。"

#: ../../library/_thread.rst:155

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:162

msgid "Lock objects have the following methods:"

msgstr "鎖物件具有以下方法："

#: ../../library/_thread.rst:167

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:171

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* 引數，則根據其值執行操作：如果為 False，只有在可以立即獲"

"取鎖而無需等待的情況下才取得鎖，而如果為 True，則像上面一樣無條件地取得鎖。"

#: ../../library/_thread.rst:176

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* 為 False，則你無法指定 *timeout*。"

#: ../../library/_thread.rst:181

msgid ""

"The return value is ``True`` if the lock is acquired successfully, ``False`` "

"if not."

msgstr "如果成功取得鎖，回傳值為 ``True``，否則為 ``False``。"

#: ../../library/_thread.rst:184

msgid "The *timeout* parameter is new."

msgstr "新增的 *timeout* 參數。"

#: ../../library/_thread.rst:187

msgid "Lock acquires can now be interrupted by signals on POSIX."

msgstr "現在取得鎖的操作可以被 POSIX 訊號中斷。"

#: ../../library/_thread.rst:190

msgid "Lock acquires can now be interrupted by signals on Windows."

msgstr "現在取得鎖的操作可以被 Windows 訊號中斷。"

#: ../../library/_thread.rst:196

msgid ""

"Releases the lock. The lock must have been acquired earlier, but not "

"necessarily by the same thread."

msgstr "釋放鎖。鎖必須先前被取得，但不一定是由同一個執行緒取得的。"

#: ../../library/_thread.rst:202

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:205

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:208

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:215

msgid "**Caveats:**"

msgstr "**注意事項：**"

#: ../../library/_thread.rst:219

msgid ""

"Interrupts always go to the main thread (the :exc:`KeyboardInterrupt` "

"exception will be received by that thread.)"

msgstr "中斷總會跳到主執行緒（該執行緒將接收 :exc:`KeyboardInterrupt` 例外。）"

#: ../../library/_thread.rst:222

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: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 "light-weight processes（輕量級行程）"

#: ../../library/_thread.rst:7

msgid "processes, light-weight"

msgstr "processes, light-weight（行程，輕量級）"

#: ../../library/_thread.rst:7

msgid "binary semaphores"

msgstr "binary semaphores（二進位號誌）"

#: ../../library/_thread.rst:7

msgid "semaphores, binary"

msgstr "semaphores, binary（號誌，二進位）"

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

msgid "module"

msgstr "module（模組）"

#: ../../library/_thread.rst:217

msgid "signal"

msgstr "signal（訊號）"

#~ 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 上則不行。"