# German translations for Python package.

# Copyright (C) 2001 Python Software Foundation

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

# Automatically generated, 2026.

#

msgid ""

msgstr ""

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

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

"POT-Creation-Date: 2026-09-28 03:11+0000\n"

"PO-Revision-Date: 2026-09-23 06:17+0000\n"

"Last-Translator: Automatically generated\n"

"Language-Team: none\n"

"Language: de\n"

"MIME-Version: 1.0\n"

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

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n != 1);\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 ""

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

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

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

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

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

#: ../../c-api/threads.rst:182

msgid "Non-Python created threads"

msgstr ""

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

#: ../../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-api/threads.rst:335

msgid ""

"This function cannot be called before :c:func:`Py_Initialize()` anymore."

msgstr ""

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

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

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

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

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

#: ../../c-api/threads.rst:688

msgid "on a :term:`bytecode` boundary;"

msgstr ""

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

#: ../../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 :term:`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 ""

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