# 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-09-22 21:56+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/asyncio-policy.rst:8

msgid "Policies"

msgstr "策略"

#: ../../library/asyncio-policy.rst:10

msgid ""

"An event loop policy is a global per-process object that controls the "

"management of the event loop. Each event loop has a default policy, which "

"can be changed and customized using the policy API."

msgstr ""

#: ../../library/asyncio-policy.rst:14

msgid ""

"A policy defines the notion of *context* and manages a separate event loop "

"per context. The default policy defines *context* to be the current thread."

msgstr ""

#: ../../library/asyncio-policy.rst:18

msgid ""

"By using a custom event loop policy, the behavior of :func:`get_event_loop`,"

" :func:`set_event_loop`, and :func:`new_event_loop` functions can be "

"customized."

msgstr ""

#: ../../library/asyncio-policy.rst:22

msgid ""

"Policy objects should implement the APIs defined in the "

":class:`AbstractEventLoopPolicy` abstract base class."

msgstr "策略对象应该实现 :class:`AbstractEventLoopPolicy` 抽象基类中定义的API。"

#: ../../library/asyncio-policy.rst:27

msgid "Getting and Setting the Policy"

msgstr "获取和设置策略"

#: ../../library/asyncio-policy.rst:29

msgid ""

"The following functions can be used to get and set the policy for the "

"current process:"

msgstr "可以使用下面函数获取和设置当前进程的策略:"

#: ../../library/asyncio-policy.rst:34

msgid "Return the current process-wide policy."

msgstr "返回当前进程域的策略。"

#: ../../library/asyncio-policy.rst:38

msgid "Set the current process-wide policy to *policy*."

msgstr "将 *policy* 设置为当前进程域策略。"

#: ../../library/asyncio-policy.rst:40

msgid "If *policy* is set to ``None``, the default policy is restored."

msgstr "如果 *policy* 设为 ``None`` 将恢复默认策略。"

#: ../../library/asyncio-policy.rst:44

msgid "Policy Objects"

msgstr "策略对象"

#: ../../library/asyncio-policy.rst:46

msgid "The abstract event loop policy base class is defined as follows:"

msgstr "抽象事件循环策略基类定义如下:"

#: ../../library/asyncio-policy.rst:50

msgid "An abstract base class for asyncio policies."

msgstr "异步策略的抽象基类。"

#: ../../library/asyncio-policy.rst:54

msgid "Get the event loop for the current context."

msgstr "为当前上下文获取事件循环。"

#: ../../library/asyncio-policy.rst:56

msgid ""

"Return an event loop object implementing the :class:`AbstractEventLoop` "

"interface."

msgstr "返回一个实现 :class:`AbstractEventLoop` 接口的事件循环对象。"

#: ../../library/asyncio-policy.rst:59 ../../library/asyncio-policy.rst:71

msgid "This method should never return ``None``."

msgstr "该方法永远不应返回 ``None``。"

#: ../../library/asyncio-policy.rst:65

msgid "Set the event loop for the current context to *loop*."

msgstr "将当前上下文的事件循环设置为 *loop* 。"

#: ../../library/asyncio-policy.rst:69

msgid "Create and return a new event loop object."

msgstr "创建并返回一个新的事件循环对象。"

#: ../../library/asyncio-policy.rst:75

msgid "Get a child process watcher object."

msgstr "获取子进程监视器对象。"

#: ../../library/asyncio-policy.rst:77

msgid ""

"Return a watcher object implementing the :class:`AbstractChildWatcher` "

"interface."

msgstr "返回一个实现 :class:`AbstractChildWatcher` 接口的监视器对象。"

#: ../../library/asyncio-policy.rst:80 ../../library/asyncio-policy.rst:86

msgid "This function is Unix specific."

msgstr "该函数仅支持Unix。"

#: ../../library/asyncio-policy.rst:84

msgid "Set the current child process watcher to *watcher*."

msgstr "将当前子进程监视器设置为 *watcher* 。"

#: ../../library/asyncio-policy.rst:89

msgid "asyncio ships with the following built-in policies:"

msgstr "asyncio附带下列内置策略:"

#: ../../library/asyncio-policy.rst:94

msgid ""

"The default asyncio policy. Uses :class:`SelectorEventLoop` on Unix and "

":class:`ProactorEventLoop` on Windows."

msgstr ""

"默认的 asyncio 策略。 在 Unix 上使用 :class:`SelectorEventLoop` 而在 Windows 上使用 "

":class:`ProactorEventLoop`。"

#: ../../library/asyncio-policy.rst:97

msgid ""

"There is no need to install the default policy manually. asyncio is "

"configured to use the default policy automatically."

msgstr "不需要手动安装默认策略。asyncio已配置成自动使用默认策略。"

#: ../../library/asyncio-policy.rst:102

msgid "On Windows, :class:`ProactorEventLoop` is now used by default."

msgstr "在 Windows 上，现在默认会使用 :class:`ProactorEventLoop`。"

#: ../../library/asyncio-policy.rst:107

msgid ""

"An alternative event loop policy that uses the :class:`SelectorEventLoop` "

"event loop implementation."

msgstr "一个使用 :class:`SelectorEventLoop` 事件循环实现的替代事件循环策略。"

#: ../../library/asyncio-policy.rst:110 ../../library/asyncio-policy.rst:118

msgid ":ref:`Availability <availability>`: Windows."

msgstr ":ref:`可用性 <availability>`: Windows。"

#: ../../library/asyncio-policy.rst:115

msgid ""

"An alternative event loop policy that uses the :class:`ProactorEventLoop` "

"event loop implementation."

msgstr "使用 :class:`ProactorEventLoop` 事件循环实现的另一种事件循环策略。"

#: ../../library/asyncio-policy.rst:123

msgid "Process Watchers"

msgstr "进程监视器"

#: ../../library/asyncio-policy.rst:125

msgid ""

"A process watcher allows customization of how an event loop monitors child "

"processes on Unix. Specifically, the event loop needs to know when a child "

"process has exited."

msgstr "进程监视器允许定制事件循环如何监视Unix子进程。具体来说，事件循环需要知道子进程何时退出。"

#: ../../library/asyncio-policy.rst:129

msgid ""

"In asyncio, child processes are created with :func:`create_subprocess_exec` "

"and :meth:`loop.subprocess_exec` functions."

msgstr ""

"在asyncio中子进程由 :func:`create_subprocess_exec` 和 :meth:`loop.subprocess_exec`"

" 函数创建。"

#: ../../library/asyncio-policy.rst:133

msgid ""

"asyncio defines the :class:`AbstractChildWatcher` abstract base class, which"

" child watchers should implement, and has four different implementations: "

":class:`ThreadedChildWatcher` (configured to be used by default), "

":class:`MultiLoopChildWatcher`, :class:`SafeChildWatcher`, and "

":class:`FastChildWatcher`."

msgstr ""

"asyncio 定义了 :class:`AbstractChildWatcher` 抽象基类，子监视器必须要实现它，并具有四种不同实现: "

":class:`ThreadedChildWatcher` (已配置为默认使用), :class:`MultiLoopChildWatcher`, "

":class:`SafeChildWatcher` 和 :class:`FastChildWatcher`。"

#: ../../library/asyncio-policy.rst:139

msgid ""

"See also the :ref:`Subprocess and Threads <asyncio-subprocess-threads>` "

"section."

msgstr "请参阅 :ref:`子进程和线程 <asyncio-subprocess-threads>` 部分。"

#: ../../library/asyncio-policy.rst:142

msgid ""

"The following two functions can be used to customize the child process "

"watcher implementation used by the asyncio event loop:"

msgstr "以下两个函数可用于自定义子进程监视器实现，它将被asyncio事件循环使用:"

#: ../../library/asyncio-policy.rst:147

msgid "Return the current child watcher for the current policy."

msgstr "返回当前策略的当前子监视器。"

#: ../../library/asyncio-policy.rst:151

msgid ""

"Set the current child watcher to *watcher* for the current policy. "

"*watcher* must implement methods defined in the "

":class:`AbstractChildWatcher` base class."

msgstr ""

"将当前策略的子监视器设置为 *watcher* 。*watcher* 必须实现 :class:`AbstractChildWatcher` "

"基类定义的方法。"

#: ../../library/asyncio-policy.rst:156

msgid ""

"Third-party event loops implementations might not support custom child "

"watchers. For such event loops, using :func:`set_child_watcher` might be "

"prohibited or have no effect."

msgstr "第三方事件循环实现可能不支持自定义子监视器。对于这样的事件循环，禁止使用 :func:`set_child_watcher` 或不起作用。"

#: ../../library/asyncio-policy.rst:164

msgid "Register a new child handler."

msgstr "注册一个新的子处理回调函数。"

#: ../../library/asyncio-policy.rst:166

msgid ""

"Arrange for ``callback(pid, returncode, *args)`` to be called when a process"

" with PID equal to *pid* terminates. Specifying another callback for the "

"same process replaces the previous handler."

msgstr ""

"安排 ``callback(pid, returncode, *args)`` 在进程的PID与 *pid* "

"相等时调用。指定另一个同进程的回调函数替换之前的回调处理函数。"

#: ../../library/asyncio-policy.rst:171

msgid "The *callback* callable must be thread-safe."

msgstr "回调函数 *callback* 必须是线程安全。"

#: ../../library/asyncio-policy.rst:175

msgid "Removes the handler for process with PID equal to *pid*."

msgstr "删除进程PID与 *pid* 相等的进程的处理函数。"

#: ../../library/asyncio-policy.rst:177

msgid ""

"The function returns ``True`` if the handler was successfully removed, "

"``False`` if there was nothing to remove."

msgstr "处理函数成功删除时返回 ``True`` ，没有删除时返回 ``False`` 。"

#: ../../library/asyncio-policy.rst:182

msgid "Attach the watcher to an event loop."

msgstr "给一个事件循环绑定监视器。"

#: ../../library/asyncio-policy.rst:184

msgid ""

"If the watcher was previously attached to an event loop, then it is first "

"detached before attaching to the new loop."

msgstr "如果监视器之前已绑定另一个事件循环，那么在绑定新循环前会先解绑原来的事件循环。"

#: ../../library/asyncio-policy.rst:187

msgid "Note: loop may be ``None``."

msgstr "注意：循环有可能是 ``None`` 。"

#: ../../library/asyncio-policy.rst:191

msgid "Return ``True`` if the watcher is ready to use."

msgstr "如果监视器已准备好使用则返回 ``True``。"

#: ../../library/asyncio-policy.rst:193

msgid ""

"Spawning a subprocess with *inactive* current child watcher raises "

":exc:`RuntimeError`."

msgstr "使用 *不活动的* 当前子监视器生成子进程将引发 :exc:`RuntimeError`。"

#: ../../library/asyncio-policy.rst:200

msgid "Close the watcher."

msgstr "关闭监视器。"

#: ../../library/asyncio-policy.rst:202

msgid ""

"This method has to be called to ensure that underlying resources are "

"cleaned-up."

msgstr "必须调用这个方法以确保相关资源会被清理。"

#: ../../library/asyncio-policy.rst:207

msgid ""

"This implementation starts a new waiting thread for every subprocess spawn."

msgstr "此实现会为每个生成的子进程启动一具新的等待线程。"

#: ../../library/asyncio-policy.rst:209

msgid ""

"It works reliably even when the asyncio event loop is run in a non-main OS "

"thread."

msgstr "即使是当 asyncio 事件循环运行在非主 OS 线程上时它也能可靠地工作。"

#: ../../library/asyncio-policy.rst:211

msgid ""

"There is no noticeable overhead when handling a big number of children "

"(*O(1)* each time a child terminates), but starting a thread per process "

"requires extra memory."

msgstr "当处理大量子进程时不存在显著的开销 (每次子进程结束时为 *O(1)*)，但当每个进程启动一个线程时则需要额外的内存。"

#: ../../library/asyncio-policy.rst:214

msgid "This watcher is used by default."

msgstr "此监视器会默认被使用。"

#: ../../library/asyncio-policy.rst:220

msgid ""

"This implementation registers a :py:data:`SIGCHLD` signal handler on "

"instantiation. That can break third-party code that installs a custom "

"handler for :py:data:`SIGCHLD` signal."

msgstr ""

"此实现会在实例化时注册一个 :py:data:`SIGCHLD` 信号处理程序。 这可能会破坏为 :py:data:`SIGCHLD` "

"信号安装自定义处理程序的第三方代码。"

#: ../../library/asyncio-policy.rst:224 ../../library/asyncio-policy.rst:242

msgid ""

"The watcher avoids disrupting other code spawning processes by polling every"

" process explicitly on a :py:data:`SIGCHLD` signal."

msgstr "此监视器会在收到 :py:data:`SIGCHLD` 信号时通过显式地轮询每个进程来避免干扰其他代码生成的进程。"

#: ../../library/asyncio-policy.rst:227

msgid ""

"There is no limitation for running subprocesses from different threads once "

"the watcher is installed."

msgstr "该监视器一旦被安装就不会限制从不同线程运行子进程。"

#: ../../library/asyncio-policy.rst:230

msgid ""

"The solution is safe but it has a significant overhead when handling a big "

"number of processes (*O(n)* each time a :py:data:`SIGCHLD` is received)."

msgstr "该解决方案是安全的，但在处理大量进程时会有显著的开销 (每收到一个 :py:data:`SIGCHLD` 时为 *O(n)*)。"

#: ../../library/asyncio-policy.rst:238

msgid ""

"This implementation uses active event loop from the main thread to handle "

":py:data:`SIGCHLD` signal. If the main thread has no running event loop "

"another thread cannot spawn a subprocess (:exc:`RuntimeError` is raised)."

msgstr ""

"该实现会使用主线程中的活动事件循环来处理 :py:data:`SIGCHLD` 信号。 如果主线程没有正在运行的事件循环，则其他线程无法生成子进程 "

"(会引发 :exc:`RuntimeError`)。"

#: ../../library/asyncio-policy.rst:245

msgid ""

"This solution is as safe as :class:`MultiLoopChildWatcher` and has the same "

"*O(N)* complexity but requires a running event loop in the main thread to "

"work."

msgstr ""

"该解决方案与 :class:`MultiLoopChildWatcher` 同样安全并同样具有 *O(N)* "

"复杂度，但需要主线程有正在运行的事件循环才能工作。"

#: ../../library/asyncio-policy.rst:250

msgid ""

"This implementation reaps every terminated processes by calling "

"``os.waitpid(-1)`` directly, possibly breaking other code spawning processes"

" and waiting for their termination."

msgstr "这种实现直接调用 ``os.waitpid(-1)`` 来获取所有已结束的进程，可能会中断其它代码洐生进程并等待它们结束。"

#: ../../library/asyncio-policy.rst:254

msgid ""

"There is no noticeable overhead when handling a big number of children "

"(*O(1)* each time a child terminates)."

msgstr "在处理大量子监视器时没有明显的开销( *O(1)* 每次子监视器结束)。"

#: ../../library/asyncio-policy.rst:257

msgid ""

"This solution requires a running event loop in the main thread to work, as "

":class:`SafeChildWatcher`."

msgstr "该解决方案需要主线程有正在运行的事件循环才能工作，这与 :class:`SafeChildWatcher` 一样。"

#: ../../library/asyncio-policy.rst:262

msgid ""

"This implementation polls process file descriptors (pidfds) to await child "

"process termination. In some respects, :class:`PidfdChildWatcher` is a "

"\"Goldilocks\" child watcher implementation. It doesn't require signals or "

"threads, doesn't interfere with any processes launched outside the event "

"loop, and scales linearly with the number of subprocesses launched by the "

"event loop. The main disadvantage is that pidfds are specific to Linux, and "

"only work on recent (5.3+) kernels."

msgstr ""

"这个实现会轮询处理文件描述符 (pidfds) 以等待子进程终结。 在某些方面，:class:`PidfdChildWatcher` "

"是一个“理想的”子进程监视器实现。 它不需要使用信号或线程，不会介入任何在事件循环以外发起的进程，并能随事件循环发起的子进程数量进行线性伸缩。 "

"其主要缺点在于 pidfds 是 Linux 专属的，并且仅在较近版本的核心（5.3+）上可用。"

#: ../../library/asyncio-policy.rst:274

msgid "Custom Policies"

msgstr "自定义策略"

#: ../../library/asyncio-policy.rst:276

msgid ""

"To implement a new event loop policy, it is recommended to subclass "

":class:`DefaultEventLoopPolicy` and override the methods for which custom "

"behavior is wanted, e.g.::"

msgstr "要实现一个新的事件循环策略，建议子类化 :class:`DefaultEventLoopPolicy` 并重写需要定制行为的方法，例如::"