asyncio-policy.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2018.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-10-11 20:40+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh <flowdas@gmail.com>\n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.0\n"

#: ../../library/asyncio-policy.rst:8
msgid "Policies"
msgstr "정책"

#: ../../library/asyncio-policy.rst:12
msgid ""
"Policies are deprecated and will be removed in Python 3.16. Users are "
"encouraged to use the :func:`asyncio.run` function or the "
":class:`asyncio.Runner` with *loop_factory* to use the desired loop "
"implementation."
msgstr ""

#: ../../library/asyncio-policy.rst:18
msgid ""
"An event loop policy is a global object used to get and set the current "
":ref:`event loop <asyncio-event-loop>`, as well as create new event "
"loops. The default policy can be :ref:`replaced <asyncio-policy-get-set>`"
" with :ref:`built-in alternatives <asyncio-policy-builtin>` to use "
"different event loop implementations, or substituted by a :ref:`custom "
"policy <asyncio-custom-policies>` that can override these behaviors."
msgstr ""

#: ../../library/asyncio-policy.rst:27
msgid ""
"The :ref:`policy object <asyncio-policy-objects>` gets and sets a "
"separate event loop per *context*. This is per-thread by default, though "
"custom policies could define *context* differently."
msgstr ""

#: ../../library/asyncio-policy.rst:32
msgid ""
"Custom event loop policies can control the behavior of "
":func:`get_event_loop`, :func:`set_event_loop`, and "
":func:`new_event_loop`."
msgstr ""
"사용자 정의 이벤트 루프 정책은 :func:`get_event_loop`, :func:`set_event_loop` 및 "
":func:`new_event_loop`\\의 동작을 제어할 수 있습니다."

#: ../../library/asyncio-policy.rst:35
msgid ""
"Policy objects should implement the APIs defined in the "
":class:`AbstractEventLoopPolicy` abstract base class."
msgstr "정책 객체는 :class:`AbstractEventLoopPolicy` 추상 베이스 클래스에 정의된 API를 구현해야 합니다."

#: ../../library/asyncio-policy.rst:42
msgid "Getting and Setting the Policy"
msgstr "정책을 얻고 설정하기"

#: ../../library/asyncio-policy.rst:44
msgid ""
"The following functions can be used to get and set the policy for the "
"current process:"
msgstr "다음 함수는 현재 프로세스의 정책을 가져오고 설정하는 데 사용할 수 있습니다:"

#: ../../library/asyncio-policy.rst:49
msgid "Return the current process-wide policy."
msgstr "현재의 프로세스 전반의 정책을 돌려줍니다."

#: ../../library/asyncio-policy.rst:51
msgid ""
"The :func:`get_event_loop_policy` function is deprecated and will be "
"removed in Python 3.16."
msgstr ""

#: ../../library/asyncio-policy.rst:57
msgid "Set the current process-wide policy to *policy*."
msgstr "현재 프로세스 전반의 정책을 *policy*\\로 설정합니다."

#: ../../library/asyncio-policy.rst:59
msgid "If *policy* is set to ``None``, the default policy is restored."
msgstr "*policy*\\를 ``None``\\으로 설정하면, 기본 정책이 복원됩니다."

#: ../../library/asyncio-policy.rst:61
msgid ""
"The :func:`set_event_loop_policy` function is deprecated and will be "
"removed in Python 3.16."
msgstr ""

#: ../../library/asyncio-policy.rst:69
msgid "Policy Objects"
msgstr "정책 객체"

#: ../../library/asyncio-policy.rst:71
msgid "The abstract event loop policy base class is defined as follows:"
msgstr "추상 이벤트 루프 정책 베이스 클래스는 다음과 같이 정의됩니다:"

#: ../../library/asyncio-policy.rst:75
msgid "An abstract base class for asyncio policies."
msgstr "asyncio 정책의 추상 베이스 클래스."

#: ../../library/asyncio-policy.rst:79
msgid "Get the event loop for the current context."
msgstr "현재 컨텍스트의 이벤트 루프를 가져옵니다."

#: ../../library/asyncio-policy.rst:81
msgid ""
"Return an event loop object implementing the :class:`AbstractEventLoop` "
"interface."
msgstr ":class:`AbstractEventLoop` 인터페이스를 구현하는 이벤트 루프 객체를 반환합니다."

#: ../../library/asyncio-policy.rst:84 ../../library/asyncio-policy.rst:96
msgid "This method should never return ``None``."
msgstr "이 메서드는 절대 ``None``\\을 반환해서는 안 됩니다."

#: ../../library/asyncio-policy.rst:90
msgid "Set the event loop for the current context to *loop*."
msgstr "현재 컨텍스트에 대한 이벤트 루프를 *loop*\\로 설정합니다."

#: ../../library/asyncio-policy.rst:94
msgid "Create and return a new event loop object."
msgstr "새 이벤트 루프 객체를 만들고 반환합니다."

#: ../../library/asyncio-policy.rst:98
#, fuzzy
msgid ""
"The :class:`AbstractEventLoopPolicy` class is deprecated and will be "
"removed in Python 3.16."
msgstr "추상 이벤트 루프 정책 베이스 클래스는 다음과 같이 정의됩니다:"

#: ../../library/asyncio-policy.rst:105
msgid "asyncio ships with the following built-in policies:"
msgstr "asyncio에는 다음과 같은 내장 정책이 제공됩니다:"

#: ../../library/asyncio-policy.rst:110
msgid ""
"The default asyncio policy.  Uses :class:`SelectorEventLoop` on Unix and "
":class:`ProactorEventLoop` on Windows."
msgstr ""
"기본 asyncio 정책. 유닉스에서는 :class:`SelectorEventLoop`\\를, 윈도우에서는 "
":class:`ProactorEventLoop`\\를 사용합니다."

#: ../../library/asyncio-policy.rst:113
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:118
msgid "On Windows, :class:`ProactorEventLoop` is now used by default."
msgstr "윈도우에서, 이제 기본적으로 :class:`ProactorEventLoop`\\가 사용됩니다."

#: ../../library/asyncio-policy.rst:120
msgid ""
"The :meth:`get_event_loop` method of the default asyncio policy now "
"raises a :exc:`RuntimeError` if there is no set event loop."
msgstr ""

#: ../../library/asyncio-policy.rst:124
msgid ""
"The :class:`DefaultEventLoopPolicy` class is deprecated and will be "
"removed in Python 3.16."
msgstr ""

#: ../../library/asyncio-policy.rst:131
msgid ""
"An alternative event loop policy that uses the :class:`SelectorEventLoop`"
" event loop implementation."
msgstr ":class:`SelectorEventLoop` 이벤트 루프 구현을 사용하는 대안 이벤트 루프 정책."

#: ../../library/asyncio-policy.rst:134 ../../library/asyncio-policy.rst:146
msgid "Availability"
msgstr "가용성"

#: ../../library/asyncio-policy.rst:136
msgid ""
"The :class:`WindowsSelectorEventLoopPolicy` class is deprecated and will "
"be removed in Python 3.16."
msgstr ""

#: ../../library/asyncio-policy.rst:143
msgid ""
"An alternative event loop policy that uses the :class:`ProactorEventLoop`"
" event loop implementation."
msgstr ":class:`ProactorEventLoop` 이벤트 루프 구현을 사용하는 대안 이벤트 루프 정책."

#: ../../library/asyncio-policy.rst:148
msgid ""
"The :class:`WindowsProactorEventLoopPolicy` class is deprecated and will "
"be removed in Python 3.16."
msgstr ""

#: ../../library/asyncio-policy.rst:156
msgid "Custom Policies"
msgstr "사용자 정의 정책"

#: ../../library/asyncio-policy.rst:158
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`\\의 서브 클래스를 만들고 사용자 "
"정의 동작이 필요한 메서드를 재정의하는 것이 좋습니다, 예를 들어::"

#: ../../library/asyncio-policy.rst:162
msgid ""
"class MyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n"
"\n"
"    def get_event_loop(self):\n"
"        \"\"\"Get the event loop.\n"
"\n"
"        This may be None or an instance of EventLoop.\n"
"        \"\"\"\n"
"        loop = super().get_event_loop()\n"
"        # Do something with loop ...\n"
"        return loop\n"
"\n"
"asyncio.set_event_loop_policy(MyEventLoopPolicy())"
msgstr ""
"class MyEventLoopPolicy(asyncio.DefaultEventLoopPolicy):\n"
"\n"
"    def get_event_loop(self):\n"
"        \"\"\"이벤트 루프를 가져옵니다.\n"
"\n"
"        None이거나 EventLoop의 인스턴스일 수 있습니다.\n"
"        \"\"\"\n"
"        loop = super().get_event_loop()\n"
"        # loop로 무언가를 합니다 ...\n"
"        return loop\n"
"\n"
"asyncio.set_event_loop_policy(MyEventLoopPolicy())"

#~ 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 ""
#~ "이벤트 루프 정책은 이벤트 루프의 관리를 제어하는 "
#~ "프로세스별 전역 객체입니다. 각 이벤트 루프는 기본 "
#~ "정책이 있는데, 정책 API를 사용하여 변경하고 사용자 "
#~ "정의할 수 있습니다."

#~ 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 ""
#~ "정책은 *컨텍스트*\\의 개념을 정의하고 컨텍스트마다 별도의 "
#~ "이벤트 루프를 관리합니다. 기본 정책은 *컨텍스트*\\를 현재"
#~ " 스레드로 정의합니다."

#~ msgid ":ref:`Availability <availability>`: Windows."
#~ msgstr ":ref:`가용성 <availability>`: 윈도우."

#~ msgid "Get a child process watcher object."
#~ msgstr "자식 프로세스 감시자 객체를 얻습니다."

#~ msgid ""
#~ "Return a watcher object implementing the"
#~ " :class:`AbstractChildWatcher` interface."
#~ msgstr ":class:`AbstractChildWatcher` 인터페이스를 구현하고 있는 감시자 객체를 돌려줍니다."

#~ msgid "This function is Unix specific."
#~ msgstr "이 함수는 유닉스 전용입니다."

#~ msgid "Set the current child process watcher to *watcher*."
#~ msgstr "현재의 자식 프로세스 감시자를 *watcher*\\로 설정합니다."

#~ msgid ""
#~ "The :meth:`get_event_loop` method of the "
#~ "default asyncio policy now emits a "
#~ ":exc:`DeprecationWarning` if there is no "
#~ "current event loop set and it "
#~ "decides to create one. In some "
#~ "future Python release this will become"
#~ " an error."
#~ msgstr ""

#~ msgid "Process Watchers"
#~ msgstr "프로세스 감시자"

#~ 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 ""
#~ "프로세스 감시자는 이벤트 루프가 유닉스에서 자식 프로세스를"
#~ " 관찰하는 방법을 사용자 정의할 수 있도록 합니다."
#~ " 특히, 이벤트 루프는 자식 프로세스가 언제 종료했는지"
#~ " 알 필요가 있습니다."

#~ 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` 함수로 만들어집니다."

#~ 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`."

#~ msgid ""
#~ "See also the :ref:`Subprocess and "
#~ "Threads <asyncio-subprocess-threads>` section."
#~ msgstr ":ref:`서브 프로세스와 스레드 <asyncio-subprocess-threads>` 절도 참조하십시오."

#~ msgid ""
#~ "The following two functions can be "
#~ "used to customize the child process "
#~ "watcher implementation used by the "
#~ "asyncio event loop:"
#~ msgstr "다음 두 함수를 사용하여 asyncio 이벤트 루프에서 사용되는 자식 프로세스 감시자 구현을 사용자 정의할 수 있습니다:"

#~ msgid "Return the current child watcher for the current policy."
#~ msgstr "현재 정책에 대한 현재 자식 감시자를 반환합니다."

#~ 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` "
#~ "베이스 클래스에 정의된 메서드를 구현해야 합니다."

#~ 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` 사용은 금지되거나 효과가"
#~ " 없습니다."

#~ msgid "Register a new child handler."
#~ msgstr "새로운 자식 처리기를 등록합니다."

#~ 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 ""
#~ "PID가 *pid* 인 프로세스가 종료할 때 "
#~ "``callback(pid, returncode, *args)``\\가 호출되도록 "
#~ "배치합니다. 같은 프로세스에 대해 다른 콜백을 지정하면 "
#~ "이전 처리기가 교체됩니다."

#~ msgid "The *callback* callable must be thread-safe."
#~ msgstr "*callback* 콜러블은 스레드 안전해야 합니다."

#~ msgid "Removes the handler for process with PID equal to *pid*."
#~ msgstr "PID가 *pid* 인 프로세스의 처리기를 제거합니다."

#~ msgid ""
#~ "The function returns ``True`` if the "
#~ "handler was successfully removed, ``False``"
#~ " if there was nothing to remove."
#~ msgstr "이 함수는 처리기가 성공적으로 제거되면 ``True``\\를, 제거할 것이 없으면 ``False``\\를 반환합니다."

#~ msgid "Attach the watcher to an event loop."
#~ msgstr "감시자를 이벤트 루프에 연결합니다."

#~ msgid ""
#~ "If the watcher was previously attached"
#~ " to an event loop, then it is"
#~ " first detached before attaching to "
#~ "the new loop."
#~ msgstr "감시자가 이전에 이벤트 루프에 연결되었으면, 새 루프에 연결하기 전에 먼저 제거됩니다."

#~ msgid "Note: loop may be ``None``."
#~ msgstr "참고: loop는 ``None`` 일 수 있습니다."

#~ msgid "Return ``True`` if the watcher is ready to use."
#~ msgstr "감시자가 사용할 준비가 되면 ``True``\\를 반환합니다."

#~ msgid ""
#~ "Spawning a subprocess with *inactive* "
#~ "current child watcher raises "
#~ ":exc:`RuntimeError`."
#~ msgstr "*활성화되지 않은* 현재 자식 감시자를 사용하여 서브 프로세스를 스폰하면 :exc:`RuntimeError`\\가 발생합니다."

#~ msgid "Close the watcher."
#~ msgstr "감시자를 닫습니다."

#~ msgid ""
#~ "This method has to be called to"
#~ " ensure that underlying resources are "
#~ "cleaned-up."
#~ msgstr "이 메서드는 하부 자원을 정리하기 위해 호출해야 합니다."

#~ msgid ""
#~ "This implementation starts a new waiting"
#~ " thread for every subprocess spawn."
#~ msgstr "이 구현은 모든 서브 프로세스 스폰에 대해 새로운 대기 스레드를 시작합니다."

#~ msgid ""
#~ "It works reliably even when the "
#~ "asyncio event loop is run in a "
#~ "non-main OS thread."
#~ msgstr "메인 외의 OS 스레드에서 asyncio 이벤트 루프가 실행되는 경우에도 신뢰성 있게 작동합니다."

#~ 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)), "
#~ "프로세스마다 스레드를 시작하는 데 추가 메모리가 필요합니다."

#~ msgid "This watcher is used by default."
#~ msgstr "기본적으로 이 감시자가 사용됩니다."

#~ 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` 시그널용 "
#~ "사용자 지정 처리기를 설치하는 제삼자 코드가 손상될 "
#~ "수 있습니다.)."

#~ msgid ""
#~ "The watcher avoids disrupting other code"
#~ " spawning processes by polling every "
#~ "process explicitly on a :py:data:`SIGCHLD` "
#~ "signal."
#~ msgstr ""
#~ "감시자는 :py:data:`SIGCHLD` 시그널에 대해 명시적으로 모든"
#~ " 프로세스를 폴링하여, 프로세스를 스포닝하는 다른 코드를 "
#~ "방해하지 않습니다."

#~ msgid ""
#~ "There is no limitation for running "
#~ "subprocesses from different threads once "
#~ "the watcher is installed."
#~ msgstr "감시자가 일단 설치되면 다른 스레드에서 서브 프로세스를 실행하는 데 제한이 없습니다."

#~ 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*))."

#~ 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`\\가 발생합니다)."

#~ 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*) 복잡성을 갖고 있지만, 작동하려면"
#~ " 메인 스레드에서 실행 중인 이벤트 루프가 필요합니다."

#~ 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)``\\를 직접 호출하여 종료된"
#~ " 모든 프로세스를 거둡니다. 프로세스를 스포닝하는 다른 "
#~ "코드를 망가뜨리고 그들의 종료를 기다릴 수 있습니다."

#~ msgid ""
#~ "There is no noticeable overhead when "
#~ "handling a big number of children "
#~ "(*O*\\ (1) each time a child "
#~ "terminates)."
#~ msgstr "많은 수의 자식을 처리할 때 눈에 띄는 오버헤드가 없습니다 (자식이 종료될 때마다 *O*\\ (1))."

#~ msgid ""
#~ "This solution requires a running event"
#~ " loop in the main thread to "
#~ "work, as :class:`SafeChildWatcher`."
#~ msgstr "이 해법은 :class:`SafeChildWatcher`\\처럼 작동하려면 메인 스레드에서 실행 중인 이벤트 루프가 필요합니다."

#~ 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 ""
#~ "이 구현은 프로세스 파일 기술자(pidfd)를 폴링하여 자식"
#~ " 프로세스 종료를 어웨이트 합니다. 어떤 면에서, "
#~ ":class:`PidfdChildWatcher`\\는 \"골디락스(Goldilocks)\" 자식 "
#~ "감시자 구현입니다. 시그널이나 스레드가 필요하지 않고, 이벤트"
#~ " 루프 외부에서 시작된 프로세스를 방해하지 않으며, "
#~ "이벤트 루프에 의해 시작된 서브 프로세스 수에 "
#~ "선형으로 확장됩니다. 가장 큰 단점은 pidfd가 리눅스에만"
#~ " 해당하며 최근 (5.3+) 커널에서만 작동한다는 것입니다."