threads.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-03-11 14:42+0000\n"
"PO-Revision-Date: 2026-02-25 14:46+0000\n"
"Last-Translator: python-doc bot, 2026\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/threads.rst:6
msgid "Thread states and the global interpreter lock"
msgstr ""

#: ../../c-api/threads.rst:13
msgid ""
"Unless on a :term:`free-threaded build` of :term:`CPython`, the Python "
"interpreter is generally not thread-safe.  In order to support multi-"
"threaded Python programs, there's a global lock, called the :term:`global "
"interpreter lock` or :term:`GIL`, that must be held by a thread before "
"accessing Python objects. Without the lock, even the simplest operations "
"could cause problems in a multi-threaded program: for example, when two "
"threads simultaneously increment the reference count of the same object, the "
"reference count could end up being incremented only once instead of twice."
msgstr ""

#: ../../c-api/threads.rst:22
msgid ""
"As such, only a thread that holds the GIL may operate on Python objects or "
"invoke Python's C API."
msgstr ""

#: ../../c-api/threads.rst:27
msgid ""
"In order to emulate concurrency, the interpreter regularly tries to switch "
"threads between bytecode instructions (see :func:`sys.setswitchinterval`). "
"This is why locks are also necessary for thread-safety in pure-Python code."
msgstr ""

#: ../../c-api/threads.rst:31
msgid ""
"Additionally, the global interpreter lock is released around blocking I/O "
"operations, such as reading or writing to a file. From the C API, this is "
"done by :ref:`detaching the thread state <detaching-thread-state>`."
msgstr ""

#: ../../c-api/threads.rst:39
msgid ""
"The Python interpreter keeps some thread-local information inside a data "
"structure called :c:type:`PyThreadState`, known as a :term:`thread state`. "
"Each thread has a thread-local pointer to a :c:type:`PyThreadState`; a "
"thread state referenced by this pointer is considered to be :term:`attached "
"<attached thread state>`."
msgstr ""

#: ../../c-api/threads.rst:44
msgid ""
"A thread can only have one :term:`attached thread state` at a time. An "
"attached thread state is typically analogous with holding the GIL, except on "
"free-threaded builds.  On builds with the GIL enabled, attaching a thread "
"state will block until the GIL can be acquired. However, even on builds with "
"the GIL disabled, it is still required to have an attached thread state, as "
"the interpreter needs to keep track of which threads may access Python "
"objects."
msgstr ""

#: ../../c-api/threads.rst:53
msgid ""
"Even on the free-threaded build, attaching a thread state may block, as the "
"GIL can be re-enabled or threads might be temporarily suspended (such as "
"during a garbage collection)."
msgstr ""

#: ../../c-api/threads.rst:57
msgid ""
"Generally, there will always be an attached thread state when using Python's "
"C API, including during embedding and when implementing methods, so it's "
"uncommon to need to set up a thread state on your own. Only in some specific "
"cases, such as in a :c:macro:`Py_BEGIN_ALLOW_THREADS` block or in a fresh "
"thread, will the thread not have an attached thread state. If uncertain, "
"check if :c:func:`PyThreadState_GetUnchecked` returns ``NULL``."
msgstr ""

#: ../../c-api/threads.rst:64
msgid ""
"If it turns out that you do need to create a thread state, call :c:func:"
"`PyThreadState_New` followed by :c:func:`PyThreadState_Swap`, or use the "
"dangerous :c:func:`PyGILState_Ensure` function."
msgstr ""

#: ../../c-api/threads.rst:72
msgid "Detaching the thread state from extension code"
msgstr ""

#: ../../c-api/threads.rst:74
msgid ""
"Most extension code manipulating the :term:`thread state` has the following "
"simple structure::"
msgstr ""

#: ../../c-api/threads.rst:77
msgid ""
"Save the thread state in a local variable.\n"
"... Do some blocking I/O operation ...\n"
"Restore the thread state from the local variable."
msgstr ""

#: ../../c-api/threads.rst:81
msgid "This is so common that a pair of macros exists to simplify it::"
msgstr ""
"この構造は非常に一般的なので、作業を単純にするために2つのマクロが用意されてい"
"ます::"

#: ../../c-api/threads.rst:83
msgid ""
"Py_BEGIN_ALLOW_THREADS\n"
"... Do some blocking I/O operation ...\n"
"Py_END_ALLOW_THREADS"
msgstr ""

#: ../../c-api/threads.rst:91
msgid ""
"The :c:macro:`Py_BEGIN_ALLOW_THREADS` macro opens a new block and declares a "
"hidden local variable; the :c:macro:`Py_END_ALLOW_THREADS` macro closes the "
"block."
msgstr ""
":c:macro:`Py_BEGIN_ALLOW_THREADS` マクロは新たなブロックを開始し、隠しローカ"
"ル変数を宣言します; :c:macro:`Py_END_ALLOW_THREADS` はブロックを閉じます。"

#: ../../c-api/threads.rst:95
msgid "The block above expands to the following code::"
msgstr "上のブロックは次のコードに展開されます::"

#: ../../c-api/threads.rst:97
msgid ""
"PyThreadState *_save;\n"
"\n"
"_save = PyEval_SaveThread();\n"
"... Do some blocking I/O operation ...\n"
"PyEval_RestoreThread(_save);"
msgstr ""

#: ../../c-api/threads.rst:107
msgid "Here is how these functions work:"
msgstr ""

#: ../../c-api/threads.rst:109
msgid ""
"The attached thread state implies that the GIL is held for the interpreter. "
"To detach it, :c:func:`PyEval_SaveThread` is called and the result is stored "
"in a local variable."
msgstr ""

#: ../../c-api/threads.rst:113
msgid ""
"By detaching the thread state, the GIL is released, which allows other "
"threads to attach to the interpreter and execute while the current thread "
"performs blocking I/O. When the I/O operation is complete, the old thread "
"state is reattached by calling :c:func:`PyEval_RestoreThread`, which will "
"wait until the GIL can be acquired."
msgstr ""

#: ../../c-api/threads.rst:120
msgid ""
"Performing blocking I/O is the most common use case for detaching the thread "
"state, but it is also useful to call it over long-running native code that "
"doesn't need access to Python objects or Python's C API. For example, the "
"standard :mod:`zlib` and :mod:`hashlib` modules detach the :term:`thread "
"state <attached thread state>` when compressing or hashing data."
msgstr ""

#: ../../c-api/threads.rst:127
msgid ""
"On a :term:`free-threaded build`, the :term:`GIL` is usually out of the "
"question, but **detaching the thread state is still required**, because the "
"interpreter periodically needs to block all threads to get a consistent view "
"of Python objects without the risk of race conditions. For example, CPython "
"currently suspends all threads for a short period of time while running the "
"garbage collector."
msgstr ""

#: ../../c-api/threads.rst:136
msgid ""
"Detaching the thread state can lead to unexpected behavior during "
"interpreter finalization. See :ref:`cautions-regarding-runtime-finalization` "
"for more details."
msgstr ""

#: ../../c-api/threads.rst:142
msgid "APIs"
msgstr ""

#: ../../c-api/threads.rst:144
msgid ""
"The following macros are normally used without a trailing semicolon; look "
"for example usage in the Python source distribution."
msgstr ""
"以下のマクロは、通常末尾にセミコロンを付けずに使います; Python ソース配布物内"
"の使用例を見てください。"

#: ../../c-api/threads.rst:149
msgid ""
"These macros are still necessary on the :term:`free-threaded build` to "
"prevent deadlocks."
msgstr ""

#: ../../c-api/threads.rst:154
msgid ""
"This macro expands to ``{ PyThreadState *_save; _save = PyEval_SaveThread();"
"``. Note that it contains an opening brace; it must be matched with a "
"following :c:macro:`Py_END_ALLOW_THREADS` macro.  See above for further "
"discussion of this macro."
msgstr ""
"このマクロを展開すると ``{ PyThreadState *_save; _save = PyEval_SaveThread();"
"`` になります。マクロに開き波括弧が入っていることに注意してください; この波括"
"弧は後で :c:macro:`Py_END_ALLOW_THREADS` マクロと対応させなければなりません。"
"マクロについての詳しい議論は上記を参照してください。"

#: ../../c-api/threads.rst:162
msgid ""
"This macro expands to ``PyEval_RestoreThread(_save); }``. Note that it "
"contains a closing brace; it must be matched with an earlier :c:macro:"
"`Py_BEGIN_ALLOW_THREADS` macro.  See above for further discussion of this "
"macro."
msgstr ""
"このマクロを展開すると ``PyEval_RestoreThread(_save); }`` になります。マクロ"
"に開き波括弧が入っていることに注意してください; この波括弧は事前の :c:macro:"
"`Py_BEGIN_ALLOW_THREADS` マクロと対応していなければなりません。マクロについて"
"の詳しい議論は上記を参照してください。"

#: ../../c-api/threads.rst:170
msgid ""
"This macro expands to ``PyEval_RestoreThread(_save);``: it is equivalent to :"
"c:macro:`Py_END_ALLOW_THREADS` without the closing brace."
msgstr ""
"このマクロを展開すると ``PyEval_RestoreThread(_save);`` になります: 閉じ波括"
"弧のない :c:macro:`Py_END_ALLOW_THREADS` と同じです。"

#: ../../c-api/threads.rst:176
msgid ""
"This macro expands to ``_save = PyEval_SaveThread();``: it is equivalent to :"
"c:macro:`Py_BEGIN_ALLOW_THREADS` without the opening brace and variable "
"declaration."
msgstr ""
"このマクロを展開すると ``_save = PyEval_SaveThread();`` になります: 開き波括"
"弧のない :c:macro:`Py_BEGIN_ALLOW_THREADS` と同じです。"

#: ../../c-api/threads.rst:182
msgid "Non-Python created threads"
msgstr "Python 以外で作られたスレッド"

#: ../../c-api/threads.rst:184
msgid ""
"When threads are created using the dedicated Python APIs (such as the :mod:"
"`threading` module), a thread state is automatically associated with them, "
"However, when a thread is created from native code (for example, by a third-"
"party library with its own thread management), it doesn't hold an attached "
"thread state."
msgstr ""

#: ../../c-api/threads.rst:190
msgid ""
"If you need to call Python code from these threads (often this will be part "
"of a callback API provided by the aforementioned third-party library), you "
"must first register these threads with the interpreter by creating a new "
"thread state and attaching it."
msgstr ""

#: ../../c-api/threads.rst:195
msgid ""
"The most robust way to do this is through :c:func:`PyThreadState_New` "
"followed by :c:func:`PyThreadState_Swap`."
msgstr ""

#: ../../c-api/threads.rst:199
msgid ""
"``PyThreadState_New`` requires an argument pointing to the desired "
"interpreter; such a pointer can be acquired via a call to :c:func:"
"`PyInterpreterState_Get` from the code where the thread was created."
msgstr ""

#: ../../c-api/threads.rst:204
msgid "For example::"
msgstr "例えば::"

#: ../../c-api/threads.rst:206
msgid ""
"/* The return value of PyInterpreterState_Get() from the\n"
"   function that created this thread. */\n"
"PyInterpreterState *interp = thread_data->interp;\n"
"\n"
"/* Create a new thread state for the interpreter. It does not start out\n"
"   attached. */\n"
"PyThreadState *tstate = PyThreadState_New(interp);\n"
"\n"
"/* Attach the thread state, which will acquire the GIL. */\n"
"PyThreadState_Swap(tstate);\n"
"\n"
"/* Perform Python actions here. */\n"
"result = CallSomeFunction();\n"
"/* evaluate result or handle exception */\n"
"\n"
"/* Destroy the thread state. No Python API allowed beyond this point. */\n"
"PyThreadState_Clear(tstate);\n"
"PyThreadState_DeleteCurrent();"
msgstr ""

#: ../../c-api/threads.rst:227
msgid ""
"If the interpreter finalized before ``PyThreadState_Swap`` was called, then "
"``interp`` will be a dangling pointer!"
msgstr ""

#: ../../c-api/threads.rst:233
msgid "Legacy API"
msgstr ""

#: ../../c-api/threads.rst:235
msgid ""
"Another common pattern to call Python code from a non-Python thread is to "
"use :c:func:`PyGILState_Ensure` followed by a call to :c:func:"
"`PyGILState_Release`."
msgstr ""

#: ../../c-api/threads.rst:238
msgid ""
"These functions do not work well when multiple interpreters exist in the "
"Python process. If no Python interpreter has ever been used in the current "
"thread (which is common for threads created outside Python), "
"``PyGILState_Ensure`` will create and attach a thread state for the \"main\" "
"interpreter (the first interpreter in the Python process)."
msgstr ""

#: ../../c-api/threads.rst:244
msgid ""
"Additionally, these functions have thread-safety issues during interpreter "
"finalization. Using ``PyGILState_Ensure`` during finalization will likely "
"crash the process."
msgstr ""

#: ../../c-api/threads.rst:248
msgid "Usage of these functions look like such::"
msgstr ""

#: ../../c-api/threads.rst:250
msgid ""
"PyGILState_STATE gstate;\n"
"gstate = PyGILState_Ensure();\n"
"\n"
"/* Perform Python actions here. */\n"
"result = CallSomeFunction();\n"
"/* evaluate result or handle exception */\n"
"\n"
"/* Release the thread. No Python API allowed beyond this point. */\n"
"PyGILState_Release(gstate);"
msgstr ""

#: ../../c-api/threads.rst:264
msgid "Cautions about fork()"
msgstr ""

#: ../../c-api/threads.rst:266
msgid ""
"Another important thing to note about threads is their behaviour in the face "
"of the C :c:func:`fork` call. On most systems with :c:func:`fork`, after a "
"process forks only the thread that issued the fork will exist.  This has a "
"concrete impact both on how locks must be handled and on all stored state in "
"CPython's runtime."
msgstr ""

#: ../../c-api/threads.rst:272
msgid ""
"The fact that only the \"current\" thread remains means any locks held by "
"other threads will never be released. Python solves this for :func:`os.fork` "
"by acquiring the locks it uses internally before the fork, and releasing "
"them afterwards. In addition, it resets any :ref:`lock-objects` in the "
"child. When extending or embedding Python, there is no way to inform Python "
"of additional (non-Python) locks that need to be acquired before or reset "
"after a fork. OS facilities such as :c:func:`!pthread_atfork` would need to "
"be used to accomplish the same thing. Additionally, when extending or "
"embedding Python, calling :c:func:`fork` directly rather than through :func:"
"`os.fork` (and returning to or calling into Python) may result in a deadlock "
"by one of Python's internal locks being held by a thread that is defunct "
"after the fork. :c:func:`PyOS_AfterFork_Child` tries to reset the necessary "
"locks, but is not always able to."
msgstr ""

#: ../../c-api/threads.rst:287
msgid ""
"The fact that all other threads go away also means that CPython's runtime "
"state there must be cleaned up properly, which :func:`os.fork` does.  This "
"means finalizing all other :c:type:`PyThreadState` objects belonging to the "
"current interpreter and all other :c:type:`PyInterpreterState` objects.  Due "
"to this and the special nature of the :ref:`\"main\" interpreter <sub-"
"interpreter-support>`, :c:func:`fork` should only be called in that "
"interpreter's \"main\" thread, where the CPython global runtime was "
"originally initialized. The only exception is if :c:func:`exec` will be "
"called immediately after."
msgstr ""

#: ../../c-api/threads.rst:300
msgid "High-level APIs"
msgstr "高水準 API"

#: ../../c-api/threads.rst:302
msgid ""
"These are the most commonly used types and functions when writing multi-"
"threaded C extensions."
msgstr ""

#: ../../c-api/threads.rst:308
msgid ""
"This data structure represents the state of a single thread.  The only "
"public data member is:"
msgstr ""

#: ../../c-api/threads.rst:313
msgid "This thread's interpreter state."
msgstr ""

#: ../../c-api/threads.rst:324
msgid "Deprecated function which does nothing."
msgstr ""

#: ../../c-api/threads.rst:326
msgid ""
"In Python 3.6 and older, this function created the GIL if it didn't exist."
msgstr ""

#: ../../c-api/threads.rst:328
msgid "The function now does nothing."
msgstr ""

#: ../../c-api/threads.rst:331
msgid ""
"This function is now called by :c:func:`Py_Initialize()`, so you don't have "
"to call it yourself anymore."
msgstr ""
"この関数は :c:func:`Py_Initialize()` から呼び出されるようになり、わざわざ呼び"
"出す必要はもう無くなりました。"

#: ../../c-api/threads.rst:335
msgid ""
"This function cannot be called before :c:func:`Py_Initialize()` anymore."
msgstr ""
"この関数は :c:func:`Py_Initialize()` より前に呼び出すことができなくなりまし"
"た。"

#: ../../c-api/threads.rst:345
msgid ""
"Detach the :term:`attached thread state` and return it. The thread will have "
"no :term:`thread state` upon returning."
msgstr ""

#: ../../c-api/threads.rst:351
msgid ""
"Set the :term:`attached thread state` to *tstate*. The passed :term:`thread "
"state` **should not** be :term:`attached <attached thread state>`, otherwise "
"deadlock ensues. *tstate* will be attached upon returning."
msgstr ""

#: ../../c-api/threads.rst:356 ../../c-api/threads.rst:640
msgid ""
"Calling this function from a thread when the runtime is finalizing will hang "
"the thread until the program exits, even if the thread was not created by "
"Python.  Refer to :ref:`cautions-regarding-runtime-finalization` for more "
"details."
msgstr ""

#: ../../c-api/threads.rst:361 ../../c-api/threads.rst:448
#: ../../c-api/threads.rst:650
msgid ""
"Hangs the current thread, rather than terminating it, if called while the "
"interpreter is finalizing."
msgstr ""

#: ../../c-api/threads.rst:367
msgid ""
"Return the :term:`attached thread state`. If the thread has no attached "
"thread state, (such as when inside of :c:macro:`Py_BEGIN_ALLOW_THREADS` "
"block), then this issues a fatal error (so that the caller needn't check for "
"``NULL``)."
msgstr ""

#: ../../c-api/threads.rst:372
msgid "See also :c:func:`PyThreadState_GetUnchecked`."
msgstr ""

#: ../../c-api/threads.rst:376
msgid ""
"Similar to :c:func:`PyThreadState_Get`, but don't kill the process with a "
"fatal error if it is NULL. The caller is responsible to check if the result "
"is NULL."
msgstr ""

#: ../../c-api/threads.rst:380
msgid ""
"In Python 3.5 to 3.12, the function was private and known as "
"``_PyThreadState_UncheckedGet()``."
msgstr ""

#: ../../c-api/threads.rst:387
msgid ""
"Set the :term:`attached thread state` to *tstate*, and return the :term:"
"`thread state` that was attached prior to calling."
msgstr ""

#: ../../c-api/threads.rst:390
msgid ""
"This function is safe to call without an :term:`attached thread state`; it "
"will simply return ``NULL`` indicating that there was no prior thread state."
msgstr ""

#: ../../c-api/threads.rst:394
msgid ":c:func:`PyEval_ReleaseThread`"
msgstr ""

#: ../../c-api/threads.rst:397
msgid ""
"Similar to :c:func:`PyGILState_Ensure`, this function will hang the thread "
"if the runtime is finalizing."
msgstr ""

#: ../../c-api/threads.rst:402
msgid "GIL-state APIs"
msgstr ""

#: ../../c-api/threads.rst:404
msgid ""
"The following functions use thread-local storage, and are not compatible "
"with sub-interpreters:"
msgstr ""
"以下の関数はスレッドローカルストレージを利用していて、サブインタプリタとの互"
"換性がありません:"

#: ../../c-api/threads.rst:409
msgid ""
"The type of the value returned by :c:func:`PyGILState_Ensure` and passed to :"
"c:func:`PyGILState_Release`."
msgstr ""

#: ../../c-api/threads.rst:414
msgid "The GIL was already held when :c:func:`PyGILState_Ensure` was called."
msgstr ""

#: ../../c-api/threads.rst:418
msgid "The GIL was not held when :c:func:`PyGILState_Ensure` was called."
msgstr ""

#: ../../c-api/threads.rst:422
msgid ""
"Ensure that the current thread is ready to call the Python C API regardless "
"of the current state of Python, or of the :term:`attached thread state`. "
"This may be called as many times as desired by a thread as long as each call "
"is matched with a call to :c:func:`PyGILState_Release`. In general, other "
"thread-related APIs may be used between :c:func:`PyGILState_Ensure` and :c:"
"func:`PyGILState_Release` calls as long as the thread state is restored to "
"its previous state before the Release().  For example, normal usage of the :"
"c:macro:`Py_BEGIN_ALLOW_THREADS` and :c:macro:`Py_END_ALLOW_THREADS` macros "
"is acceptable."
msgstr ""

#: ../../c-api/threads.rst:432
msgid ""
"The return value is an opaque \"handle\" to the :term:`attached thread "
"state` when :c:func:`PyGILState_Ensure` was called, and must be passed to :c:"
"func:`PyGILState_Release` to ensure Python is left in the same state. Even "
"though recursive calls are allowed, these handles *cannot* be shared - each "
"unique call to :c:func:`PyGILState_Ensure` must save the handle for its call "
"to :c:func:`PyGILState_Release`."
msgstr ""

#: ../../c-api/threads.rst:439
msgid ""
"When the function returns, there will be an :term:`attached thread state` "
"and the thread will be able to call arbitrary Python code.  Failure is a "
"fatal error."
msgstr ""

#: ../../c-api/threads.rst:443
msgid ""
"Calling this function when the runtime is finalizing is unsafe. Doing so "
"will either hang the thread until the program ends, or fully crash the "
"interpreter in rare cases. Refer to :ref:`cautions-regarding-runtime-"
"finalization` for more details."
msgstr ""

#: ../../c-api/threads.rst:454
msgid ""
"Release any resources previously acquired.  After this call, Python's state "
"will be the same as it was prior to the corresponding :c:func:"
"`PyGILState_Ensure` call (but generally this state will be unknown to the "
"caller, hence the use of the GILState API)."
msgstr ""
"獲得したすべてのリソースを解放します。この関数を呼び出すと、Pythonの状態は対"
"応する :c:func:`PyGILState_Ensure` を呼び出す前と同じとなります (通常、この状"
"態は呼び出し元でははわかりませんので、GILState APIを利用するようにしてくださ"
"い)。"

#: ../../c-api/threads.rst:459
msgid ""
"Every call to :c:func:`PyGILState_Ensure` must be matched by a call to :c:"
"func:`PyGILState_Release` on the same thread."
msgstr ""
":c:func:`PyGILState_Ensure` を呼び出す場合は、必ず同一スレッド内で対応する :"
"c:func:`PyGILState_Release` を呼び出してください。"

#: ../../c-api/threads.rst:464
msgid ""
"Get the :term:`attached thread state` for this thread.  May return ``NULL`` "
"if no GILState API has been used on the current thread.  Note that the main "
"thread always has such a thread-state, even if no auto-thread-state call has "
"been made on the main thread.  This is mainly a helper/diagnostic function."
msgstr ""

#: ../../c-api/threads.rst:470
msgid ""
"This function may return non-``NULL`` even when the :term:`thread state` is "
"detached. Prefer :c:func:`PyThreadState_Get` or :c:func:"
"`PyThreadState_GetUnchecked` for most cases."
msgstr ""

#: ../../c-api/threads.rst:475
msgid ":c:func:`PyThreadState_Get`"
msgstr ""

#: ../../c-api/threads.rst:479
msgid ""
"Return ``1`` if the current thread is holding the :term:`GIL` and ``0`` "
"otherwise. This function can be called from any thread at any time. Only if "
"it has had its :term:`thread state <attached thread state>` initialized via :"
"c:func:`PyGILState_Ensure` will it return ``1``. This is mainly a helper/"
"diagnostic function.  It can be useful for example in callback contexts or "
"memory allocation functions when knowing that the :term:`GIL` is locked can "
"allow the caller to perform sensitive actions or otherwise behave "
"differently."
msgstr ""

#: ../../c-api/threads.rst:489
msgid ""
"If the current Python process has ever created a subinterpreter, this "
"function will *always* return ``1``. Prefer :c:func:"
"`PyThreadState_GetUnchecked` for most cases."
msgstr ""

#: ../../c-api/threads.rst:497
msgid "Low-level APIs"
msgstr "低水準 API"

#: ../../c-api/threads.rst:501
msgid ""
"Create a new thread state object belonging to the given interpreter object. "
"An :term:`attached thread state` is not needed."
msgstr ""

#: ../../c-api/threads.rst:506
msgid ""
"Reset all information in a :term:`thread state` object.  *tstate* must be :"
"term:`attached <attached thread state>`"
msgstr ""

#: ../../c-api/threads.rst:509
msgid ""
"This function now calls the :c:member:`!PyThreadState.on_delete` callback. "
"Previously, that happened in :c:func:`PyThreadState_Delete`."
msgstr ""

#: ../../c-api/threads.rst:513
msgid "The :c:member:`!PyThreadState.on_delete` callback was removed."
msgstr ""

#: ../../c-api/threads.rst:519
msgid ""
"Destroy a :term:`thread state` object.  *tstate* should not be :term:"
"`attached <attached thread state>` to any thread. *tstate* must have been "
"reset with a previous call to :c:func:`PyThreadState_Clear`."
msgstr ""

#: ../../c-api/threads.rst:527
msgid ""
"Detach the :term:`attached thread state` (which must have been reset with a "
"previous call to :c:func:`PyThreadState_Clear`) and then destroy it."
msgstr ""

#: ../../c-api/threads.rst:530
msgid ""
"No :term:`thread state` will be :term:`attached <attached thread state>` "
"upon returning."
msgstr ""

#: ../../c-api/threads.rst:535
msgid "Get the current frame of the Python thread state *tstate*."
msgstr ""

#: ../../c-api/threads.rst:537
msgid ""
"Return a :term:`strong reference`. Return ``NULL`` if no frame is currently "
"executing."
msgstr ""

#: ../../c-api/threads.rst:540
msgid "See also :c:func:`PyEval_GetFrame`."
msgstr ""

#: ../../c-api/threads.rst:542 ../../c-api/threads.rst:551
#: ../../c-api/threads.rst:560
msgid ""
"*tstate* must not be ``NULL``, and must be :term:`attached <attached thread "
"state>`."
msgstr ""

#: ../../c-api/threads.rst:549
msgid ""
"Get the unique :term:`thread state` identifier of the Python thread state "
"*tstate*."
msgstr ""

#: ../../c-api/threads.rst:558
msgid "Get the interpreter of the Python thread state *tstate*."
msgstr ""

#: ../../c-api/threads.rst:567
msgid "Suspend tracing and profiling in the Python thread state *tstate*."
msgstr ""

#: ../../c-api/threads.rst:569
msgid "Resume them using the :c:func:`PyThreadState_LeaveTracing` function."
msgstr ""

#: ../../c-api/threads.rst:576
msgid ""
"Resume tracing and profiling in the Python thread state *tstate* suspended "
"by the :c:func:`PyThreadState_EnterTracing` function."
msgstr ""

#: ../../c-api/threads.rst:579
msgid ""
"See also :c:func:`PyEval_SetTrace` and :c:func:`PyEval_SetProfile` functions."
msgstr ""

#: ../../c-api/threads.rst:587
msgid ""
"Set the stack protection start address and stack protection size of a Python "
"thread state."
msgstr ""

#: ../../c-api/threads.rst:590
msgid ""
"On success, return ``0``. On failure, set an exception and return ``-1``."
msgstr ""

#: ../../c-api/threads.rst:593
msgid ""
"CPython implements :ref:`recursion control <recursion>` for C code by "
"raising :py:exc:`RecursionError` when it notices that the machine execution "
"stack is close to overflow. See for example the :c:func:"
"`Py_EnterRecursiveCall` function. For this, it needs to know the location of "
"the current thread's stack, which it normally gets from the operating "
"system. When the stack is changed, for example using context switching "
"techniques like the Boost library's ``boost::context``, you must call :c:"
"func:`~PyUnstable_ThreadState_SetStackProtection` to inform CPython of the "
"change."
msgstr ""

#: ../../c-api/threads.rst:602
msgid ""
"Call :c:func:`~PyUnstable_ThreadState_SetStackProtection` either before or "
"after changing the stack. Do not call any other Python C API between the "
"call and the stack change."
msgstr ""

#: ../../c-api/threads.rst:607
msgid ""
"See :c:func:`PyUnstable_ThreadState_ResetStackProtection` for undoing this "
"operation."
msgstr ""

#: ../../c-api/threads.rst:614
msgid ""
"Reset the stack protection start address and stack protection size of a "
"Python thread state to the operating system defaults."
msgstr ""

#: ../../c-api/threads.rst:617
msgid ""
"See :c:func:`PyUnstable_ThreadState_SetStackProtection` for an explanation."
msgstr ""

#: ../../c-api/threads.rst:624
msgid ""
"Return a dictionary in which extensions can store thread-specific state "
"information.  Each extension should use a unique key to use to store state "
"in the dictionary.  It is okay to call this function when no :term:`thread "
"state` is :term:`attached <attached thread state>`. If this function returns "
"``NULL``, no exception has been raised and the caller should assume no "
"thread state is attached."
msgstr ""

#: ../../c-api/threads.rst:634
msgid ""
":term:`Attach <attached thread state>` *tstate* to the current thread, which "
"must not be ``NULL`` or already :term:`attached <attached thread state>`."
msgstr ""

#: ../../c-api/threads.rst:637
msgid ""
"The calling thread must not already have an :term:`attached thread state`."
msgstr ""

#: ../../c-api/threads.rst:645
msgid ""
"Updated to be consistent with :c:func:`PyEval_RestoreThread`, :c:func:"
"`Py_END_ALLOW_THREADS`, and :c:func:`PyGILState_Ensure`, and terminate the "
"current thread if called while the interpreter is finalizing."
msgstr ""

#: ../../c-api/threads.rst:654
msgid ""
":c:func:`PyEval_RestoreThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""
":c:func:`PyEval_RestoreThread` はいつでも (スレッドが初期化されたいないときで"
"も) 利用可能な高レベル関数です。"

#: ../../c-api/threads.rst:660
msgid ""
"Detach the :term:`attached thread state`. The *tstate* argument, which must "
"not be ``NULL``, is only used to check that it represents the :term:"
"`attached thread state` --- if it isn't, a fatal error is reported."
msgstr ""

#: ../../c-api/threads.rst:665
msgid ""
":c:func:`PyEval_SaveThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""
":c:func:`PyEval_SaveThread` はより高レベルな関数で常に (スレッドが初期化され"
"ていないときでも) 利用できます。"

#: ../../c-api/threads.rst:670
msgid "Asynchronous notifications"
msgstr ""

#: ../../c-api/threads.rst:672
msgid ""
"A mechanism is provided to make asynchronous notifications to the main "
"interpreter thread.  These notifications take the form of a function pointer "
"and a void pointer argument."
msgstr ""
"インタプリタのメインスレッドに非同期な通知を行うために提供されている仕組みで"
"す。これらの通知は関数ポインタと void ポインタ引数という形態を取ります。"

#: ../../c-api/threads.rst:679
msgid ""
"Schedule a function to be called from the main interpreter thread.  On "
"success, ``0`` is returned and *func* is queued for being called in the main "
"thread.  On failure, ``-1`` is returned without setting any exception."
msgstr ""
"インタプリタのメインスレッドから関数が呼び出される予定を組みます。成功すると "
"``0`` が返り、*func* はメインスレッドの呼び出しキューに詰められます。失敗する"
"と、例外をセットせずに ``-1`` が返ります。"

#: ../../c-api/threads.rst:683
msgid ""
"When successfully queued, *func* will be *eventually* called from the main "
"interpreter thread with the argument *arg*.  It will be called "
"asynchronously with respect to normally running Python code, but with both "
"these conditions met:"
msgstr ""
"無事にキューに詰められると、*func* は *いつかは必ず* インタプリタのメインス"
"レッドから、*arg* を引数として呼び出されます。この関数は、通常の実行中の "
"Python コードに対して非同期に呼び出されますが、次の両方の条件に合致したときに"
"呼び出されます:"

#: ../../c-api/threads.rst:688
msgid "on a :term:`bytecode` boundary;"
msgstr ":term:`bytecode` 境界上にいるとき、"

#: ../../c-api/threads.rst:689
msgid ""
"with the main thread holding an :term:`attached thread state` (*func* can "
"therefore use the full C API)."
msgstr ""

#: ../../c-api/threads.rst:692
msgid ""
"*func* must return ``0`` on success, or ``-1`` on failure with an exception "
"set.  *func* won't be interrupted to perform another asynchronous "
"notification recursively, but it can still be interrupted to switch threads "
"if the :term:`thread state <attached thread state>` is detached."
msgstr ""

#: ../../c-api/threads.rst:697
msgid ""
"This function doesn't need an :term:`attached thread state`. However, to "
"call this function in a subinterpreter, the caller must have an :term:"
"`attached thread state`. Otherwise, the function *func* can be scheduled to "
"be called from the wrong interpreter."
msgstr ""

#: ../../c-api/threads.rst:702
msgid ""
"This is a low-level function, only useful for very special cases. There is "
"no guarantee that *func* will be called as quick as possible.  If the main "
"thread is busy executing a system call, *func* won't be called before the "
"system call returns.  This function is generally **not** suitable for "
"calling Python code from arbitrary C threads.  Instead, use the :ref:"
"`PyGILState API<gilstate>`."
msgstr ""
"これは、非常に特別な場合にのみ役立つ、低レベルな関数です。 *func* が可能な限"
"り早く呼び出される保証はありません。メインスレッドがシステムコールを実行する"
"のに忙しい場合は、 *func* はシステムコールが返ってくるまで呼び出されないで"
"しょう。この関数は一般的には、任意の C スレッドから Python コードを呼び出すの"
"には **向きません** 。これの代わりに、 :ref:`PyGILState API<gilstate>` を使用"
"してください。"

#: ../../c-api/threads.rst:711
msgid ""
"If this function is called in a subinterpreter, the function *func* is now "
"scheduled to be called from the subinterpreter, rather than being called "
"from the main interpreter. Each subinterpreter now has its own list of "
"scheduled calls."
msgstr ""

#: ../../c-api/threads.rst:717
msgid ""
"This function now always schedules *func* to be run in the main interpreter."
msgstr ""

#: ../../c-api/threads.rst:724
msgid ""
"Execute all pending calls. This is usually executed automatically by the "
"interpreter."
msgstr ""

#: ../../c-api/threads.rst:727
msgid ""
"This function returns ``0`` on success, and returns ``-1`` with an exception "
"set on failure."
msgstr ""

#: ../../c-api/threads.rst:730
msgid ""
"If this is not called in the main thread of the main interpreter, this "
"function does nothing and returns ``0``. The caller must hold an :term:"
"`attached thread state`."
msgstr ""

#: ../../c-api/threads.rst:736
msgid "This function only runs pending calls in the main interpreter."
msgstr ""

#: ../../c-api/threads.rst:742
msgid ""
"Asynchronously raise an exception in a thread. The *id* argument is the "
"thread id of the target thread; *exc* is the exception object to be raised. "
"This function does not steal any references to *exc*. To prevent naive "
"misuse, you must write your own C extension to call this.  Must be called "
"with an :term:`attached thread state`. Returns the number of thread states "
"modified; this is normally one, but will be zero if the thread id isn't "
"found.  If *exc* is ``NULL``, the pending exception (if any) for the thread "
"is cleared. This raises no exceptions."
msgstr ""

#: ../../c-api/threads.rst:750
msgid ""
"The type of the *id* parameter changed from :c:expr:`long` to :c:expr:"
"`unsigned long`."
msgstr ""
"*id* 引数の型が :c:expr:`long` から :c:expr:`unsigned long` へ変更されまし"
"た。"

#: ../../c-api/threads.rst:756
msgid "Operating system thread APIs"
msgstr ""

#: ../../c-api/threads.rst:760
msgid "Sentinel value for an invalid thread ID."
msgstr ""

#: ../../c-api/threads.rst:762
msgid "This is currently equivalent to ``(unsigned long)-1``."
msgstr ""

#: ../../c-api/threads.rst:767
msgid ""
"Start function *func* in a new thread with argument *arg*. The resulting "
"thread is not intended to be joined."
msgstr ""

#: ../../c-api/threads.rst:770
msgid "*func* must not be ``NULL``, but *arg* may be ``NULL``."
msgstr ""

#: ../../c-api/threads.rst:772
msgid ""
"On success, this function returns the identifier of the new thread; on "
"failure, this returns :c:macro:`PYTHREAD_INVALID_THREAD_ID`."
msgstr ""

#: ../../c-api/threads.rst:775 ../../c-api/threads.rst:859
#: ../../c-api/threads.rst:867
msgid "The caller does not need to hold an :term:`attached thread state`."
msgstr ""

#: ../../c-api/threads.rst:780
msgid "Return the identifier of the current thread, which will never be zero."
msgstr ""

#: ../../c-api/threads.rst:782 ../../c-api/threads.rst:814
msgid ""
"This function cannot fail, and the caller does not need to hold an :term:"
"`attached thread state`."
msgstr ""

#: ../../c-api/threads.rst:786
msgid ":py:func:`threading.get_ident`"
msgstr ""

#: ../../c-api/threads.rst:791
msgid ""
"Get general information about the current thread in the form of a :ref:"
"`struct sequence <struct-sequence-objects>` object. This information is "
"accessible as :py:attr:`sys.thread_info` in Python."
msgstr ""

#: ../../c-api/threads.rst:795
msgid ""
"On success, this returns a new :term:`strong reference` to the thread "
"information; on failure, this returns ``NULL`` with an exception set."
msgstr ""

#: ../../c-api/threads.rst:798
msgid "The caller must hold an :term:`attached thread state`."
msgstr ""

#: ../../c-api/threads.rst:803
msgid "This macro is defined when the system supports native thread IDs."
msgstr ""

#: ../../c-api/threads.rst:808
msgid ""
"Get the native identifier of the current thread as it was assigned by the "
"operating system's kernel, which will never be less than zero."
msgstr ""

#: ../../c-api/threads.rst:811
msgid ""
"This function is only available when :c:macro:`PY_HAVE_THREAD_NATIVE_ID` is "
"defined."
msgstr ""

#: ../../c-api/threads.rst:818
msgid ":py:func:`threading.get_native_id`"
msgstr ""

#: ../../c-api/threads.rst:823
msgid ""
"Terminate the current thread. This function is generally considered unsafe "
"and should be avoided. It is kept solely for backwards compatibility."
msgstr ""

#: ../../c-api/threads.rst:826
msgid ""
"This function is only safe to call if all functions in the full call stack "
"are written to safely allow it."
msgstr ""

#: ../../c-api/threads.rst:831
msgid ""
"If the current system uses POSIX threads (also known as \"pthreads\"), this "
"calls :manpage:`pthread_exit(3)`, which attempts to unwind the stack and "
"call C++ destructors on some libc implementations. However, if a "
"``noexcept`` function is reached, it may terminate the process. Other "
"systems, such as macOS, do unwinding."
msgstr ""

#: ../../c-api/threads.rst:837
msgid ""
"On Windows, this function calls ``_endthreadex()``, which kills the thread "
"without calling C++ destructors."
msgstr ""

#: ../../c-api/threads.rst:840
msgid "In any case, there is a risk of corruption on the thread's stack."
msgstr ""

#: ../../c-api/threads.rst:847
msgid ""
"Initialize ``PyThread*`` APIs. Python executes this function automatically, "
"so there's little need to call it from an extension module."
msgstr ""

#: ../../c-api/threads.rst:853
msgid "Set the stack size of the current thread to *size* bytes."
msgstr ""

#: ../../c-api/threads.rst:855
msgid ""
"This function returns ``0`` on success, ``-1`` if *size* is invalid, or "
"``-2`` if the system does not support changing the stack size. This function "
"does not set exceptions."
msgstr ""

#: ../../c-api/threads.rst:864
msgid ""
"Return the stack size of the current thread in bytes, or ``0`` if the "
"system's default stack size is in use."
msgstr ""

#: ../../c-api/threads.rst:8
msgid "global interpreter lock"
msgstr "global interpreter lock"

#: ../../c-api/threads.rst:8
msgid "interpreter lock"
msgstr "interpreter lock"

#: ../../c-api/threads.rst:8
msgid "lock, interpreter"
msgstr "lock, interpreter"

#: ../../c-api/threads.rst:25
msgid "setswitchinterval (in module sys)"
msgstr ""

#: ../../c-api/threads.rst:36
msgid "PyThreadState (C type)"
msgstr ""

#: ../../c-api/threads.rst:87
msgid "Py_BEGIN_ALLOW_THREADS (C macro)"
msgstr ""

#: ../../c-api/threads.rst:87
msgid "Py_END_ALLOW_THREADS (C macro)"
msgstr ""

#: ../../c-api/threads.rst:103
msgid "PyEval_RestoreThread (C function)"
msgstr ""

#: ../../c-api/threads.rst:103
msgid "PyEval_SaveThread (C function)"
msgstr ""

#: ../../c-api/threads.rst:318
msgid "PyEval_AcquireThread()"
msgstr "PyEval_AcquireThread()"

#: ../../c-api/threads.rst:318
msgid "PyEval_ReleaseThread()"
msgstr "PyEval_ReleaseThread()"

#: ../../c-api/threads.rst:318
msgid "PyEval_SaveThread()"
msgstr "PyEval_SaveThread()"

#: ../../c-api/threads.rst:318
msgid "PyEval_RestoreThread()"
msgstr "PyEval_RestoreThread()"

#: ../../c-api/threads.rst:340
msgid "module"
msgstr "module"

#: ../../c-api/threads.rst:340
msgid "_thread"
msgstr "_thread"