_thread.po

# Copyright (C) 2001-2024, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2024-10-12 00:13+0000\n"
"PO-Revision-Date: 2015-12-09 17:51+0000\n"
"Last-Translator: Liang-Bo Wang <me@liang2.tw>\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:193
msgid ""
"Releases the lock.  The lock must have been acquired earlier, but not "
"necessarily by the same thread."
msgstr "釋放鎖。鎖必須先前被取得，但不一定是由同一個執行緒取得的。"

#: ../../library/_thread.rst:199
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:202
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:205
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:212
msgid "**Caveats:**"
msgstr "**注意事項：**"

#: ../../library/_thread.rst:216
msgid ""
"Interrupts always go to the main thread (the :exc:`KeyboardInterrupt` "
"exception will be received by that thread.)"
msgstr "中斷總會跳到主執行緒（該執行緒將接收 :exc:`KeyboardInterrupt` 例外。）"

#: ../../library/_thread.rst:219
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:222
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:228
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:214
msgid "module"
msgstr "module（模組）"

#: ../../library/_thread.rst:214
msgid "signal"
msgstr "signal（訊號）"