_thread.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-09-15 15:19+0000\n"
"PO-Revision-Date: 2025-09-15 01:03+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../library/_thread.rst:2
msgid ":mod:`!_thread` --- Low-level threading API"
msgstr ":mod:`!_thread`--- API de segmentação de baixo nível"

#: ../../library/_thread.rst:15
msgid ""
"This module provides low-level primitives for working with multiple threads "
"(also called :dfn:`light-weight processes` or :dfn:`tasks`) --- multiple "
"threads of control sharing their global data space.  For synchronization, "
"simple locks (also called :dfn:`mutexes` or :dfn:`binary semaphores`) are "
"provided. The :mod:`threading` module provides an easier to use and higher-"
"level threading API built on top of this module."
msgstr ""
"Este módulo fornece primitivos de baixo nível para trabalhar com vários "
"threads (também chamados :dfn:`processos leves` ou :dfn:`tarefas`) --- "
"vários threads de controle compartilhando seu espaço de dados global. Para "
"sincronização, travas simples (também chamadas de :dfn:`mutexes`, :dfn:"
"`exclusão mútua` ou :dfn:`semáforos binários`) são fornecidas. O módulo :mod:"
"`threading` fornece uma API de segmentação mais fácil de usar e de nível "
"mais alto, construída sobre este módulo."

#: ../../library/_thread.rst:26
msgid "This module used to be optional, it is now always available."
msgstr "Este módulo costumava ser opcional, agora está sempre disponível."

#: ../../library/_thread.rst:29
msgid "This module defines the following constants and functions:"
msgstr "Este módulo define as seguintes constantes e funções:"

#: ../../library/_thread.rst:33
msgid "Raised on thread-specific errors."
msgstr "Gerado em erros específicos de segmento."

#: ../../library/_thread.rst:35
msgid "This is now a synonym of the built-in :exc:`RuntimeError`."
msgstr "Agora este é um sinônimo da exceção embutida :exc:`RuntimeError`."

#: ../../library/_thread.rst:41
msgid "This is the type of lock objects."
msgstr "Este é o tipo de objetos de trava."

#: ../../library/_thread.rst:46
msgid ""
"Start a new thread and return its identifier.  The thread executes the "
"function *function* with the argument list *args* (which must be a tuple). "
"The optional *kwargs* argument specifies a dictionary of keyword arguments."
msgstr ""
"Começa uma nova thread e retorna seu identificador. A thread executa a "
"função *function* com a lista de argumentos *args* (que deve ser uma tupla). "
"O argumento opcional *kwargs* especifica um dicionário de argumentos "
"nomeados."

#: ../../library/_thread.rst:50
msgid "When the function returns, the thread silently exits."
msgstr "Quando a função retorna, a thread termina silenciosamente."

#: ../../library/_thread.rst:52
msgid ""
"When the function terminates with an unhandled exception, :func:`sys."
"unraisablehook` is called to handle the exception. The *object* attribute of "
"the hook argument is *function*. By default, a stack trace is printed and "
"then the thread exits (but other threads continue to run)."
msgstr ""
"Quando a função termina com uma exceção não processada, :func:`sys."
"unraisablehook` é chamada para lidar com a exceção. O atributo *object* do "
"argumento do hook é *function*. Por padrão, um stack trace (situação da "
"pilha de execução) é exibido e, em seguida, a thread termina (mas outras "
"threads continuam a ser executadas)."

#: ../../library/_thread.rst:57
msgid ""
"When the function raises a :exc:`SystemExit` exception, it is silently "
"ignored."
msgstr "Quando a função gera uma exceção :exc:`SystemExit`, ela é ignorada."

#: ../../library/_thread.rst:60
msgid ""
"Raises an :ref:`auditing event <auditing>` ``_thread.start_new_thread`` with "
"arguments ``function``, ``args``, ``kwargs``."
msgstr ""
"Levanta um :ref:`evento de auditoria <auditing>` ``_thread."
"start_new_thread`` com os argumentos ``function``, ``args``, ``kwargs``."

#: ../../library/_thread.rst:62
msgid ":func:`sys.unraisablehook` is now used to handle unhandled exceptions."
msgstr ""
":func:`sys.unraisablehook` agora é usada para tratar exceções não tratadas."

#: ../../library/_thread.rst:68
msgid ""
"Simulate the effect of a signal arriving in the main thread. A thread can "
"use this function to interrupt the main thread, though there is no guarantee "
"that the interruption will happen immediately."
msgstr ""
"Simula o efeito de um sinal chegando na thread principal. Uma thread pode "
"usar esta função para interromper a thread principal, embora não haja "
"garantia de que a interrupção ocorrerá imediatamente."

#: ../../library/_thread.rst:72
msgid ""
"If given, *signum* is the number of the signal to simulate. If *signum* is "
"not given, :const:`signal.SIGINT` is simulated."
msgstr ""
"Se fornecido, *signum* é o número do sinal a ser simulado. Se *signum* não "
"for fornecido, :const:`signal.SIGINT` será simulado."

#: ../../library/_thread.rst:75
msgid ""
"If the given signal isn't handled by Python (it was set to :const:`signal."
"SIG_DFL` or :const:`signal.SIG_IGN`), this function does nothing."
msgstr ""
"Se o sinal fornecido não for tratado pelo Python (o sinal foi definido como :"
"const:`signal.SIG_DFL` ou :const:`signal.SIG_IGN`), esta função faz nada."

#: ../../library/_thread.rst:79
msgid "The *signum* argument is added to customize the signal number."
msgstr "O argumento *signum* é adicionado para personalizar o sinal de número."

#: ../../library/_thread.rst:83
msgid ""
"This does not emit the corresponding signal but schedules a call to the "
"associated handler (if it exists). If you want to truly emit the signal, "
"use :func:`signal.raise_signal`."
msgstr ""
"Isso não emite o sinal correspondente, mas agenda uma chamada para o "
"tratador associado (se existir). Se você quer realmente emitir o sinal, use :"
"func:`signal.raise_signal`."

#: ../../library/_thread.rst:90
msgid ""
"Raise the :exc:`SystemExit` exception.  When not caught, this will cause the "
"thread to exit silently."
msgstr ""
"Levanta a exceção :exc:`SystemExit`. Quando não for detectada, a thread "
"terminará silenciosamente."

#: ../../library/_thread.rst:104
msgid ""
"Return a new lock object.  Methods of locks are described below.  The lock "
"is initially unlocked."
msgstr ""
"Retorna um novo objeto de trava. Métodos de trava são descritos abaixo. A "
"trava é desativada inicialmente."

#: ../../library/_thread.rst:110
msgid ""
"Return the 'thread identifier' of the current thread.  This is a nonzero "
"integer.  Its value has no direct meaning; it is intended as a magic cookie "
"to be used e.g. to index a dictionary of thread-specific data.  Thread "
"identifiers may be recycled when a thread exits and another thread is "
"created."
msgstr ""
"Retorna o 'identificador de thread' do thread atual. Este é um número "
"inteiro diferente de zero. Seu valor não tem significado direto; pretende-se "
"que seja um cookie mágico para ser usado, por exemplo, para indexar um "
"dicionário de dados específicos do thread. identificadores de thread podem "
"ser reciclados quando um thread sai e outro é criado."

#: ../../library/_thread.rst:118
msgid ""
"Return the native integral Thread ID of the current thread assigned by the "
"kernel. This is a non-negative integer. Its value may be used to uniquely "
"identify this particular thread system-wide (until the thread terminates, "
"after which the value may be recycled by the OS)."
msgstr ""
"Retorna a ID de thread integral nativa da thread atual atribuída pelo "
"kernel. Este é um número inteiro não negativo. Seu valor pode ser usado para "
"identificar exclusivamente essa thread específica em todo o sistema (até que "
"a thread termine, após o que o valor poderá ser reciclado pelo sistema "
"operacional)."

#: ../../library/_thread.rst:123 ../../library/_thread.rst:148
msgid "Availability"
msgstr "Disponibilidade"

#: ../../library/_thread.rst:127
msgid "Added support for GNU/kFreeBSD."
msgstr "Adicionado suporte a GNU/kFreeBSD."

#: ../../library/_thread.rst:133
msgid ""
"Return the thread stack size used when creating new threads.  The optional "
"*size* argument specifies the stack size to be used for subsequently created "
"threads, and must be 0 (use platform or configured default) or a positive "
"integer value of at least 32,768 (32 KiB). If *size* is not specified, 0 is "
"used.  If changing the thread stack size is unsupported, a :exc:"
"`RuntimeError` is raised.  If the specified stack size is invalid, a :exc:"
"`ValueError` is raised and the stack size is unmodified.  32 KiB is "
"currently the minimum supported stack size value to guarantee sufficient "
"stack space for the interpreter itself.  Note that some platforms may have "
"particular restrictions on values for the stack size, such as requiring a "
"minimum stack size > 32 KiB or requiring allocation in multiples of the "
"system memory page size - platform documentation should be referred to for "
"more information (4 KiB pages are common; using multiples of 4096 for the "
"stack size is the suggested approach in the absence of more specific "
"information)."
msgstr ""
"Retorna o tamanho da pilha de threads usado ao criar novos threads. O "
"argumento opcional *size* especifica o tamanho da pilha a ser usado para "
"threads criados posteriormente e deve ser 0 (usar plataforma ou padrão "
"configurado) ou um valor inteiro positivo de pelo menos 32.768 (32 KiB). Se "
"*size* não for especificado, 0 será usado. Se a alteração do tamanho da "
"pilha de threads não for suportada, uma :exc:`RuntimeError` será levantada. "
"Se o tamanho da pilha especificado for inválido, uma :exc:`ValueError` será "
"levantada e o tamanho da pilha não será modificado. Atualmente, 0 KiB é o "
"valor mínimo de tamanho de pilha suportado para garantir espaço suficiente "
"para o próprio interpretador. Observe que algumas plataformas podem ter "
"restrições específicas sobre valores para o tamanho da pilha, como exigir um "
"tamanho mínimo de pilha > 32 KiB ou exigir alocação em múltiplos do tamanho "
"da página de memória do sistema -- a documentação da plataforma deve ser "
"consultada para obter mais informações (4 páginas KiB são comuns; usar "
"múltiplos de 4096 para o tamanho da pilha é a abordagem sugerida na ausência "
"de informações mais específicas)."

#: ../../library/_thread.rst:150
msgid "Unix platforms with POSIX threads support."
msgstr "Plataformas Unix com suporte a threads POSIX."

#: ../../library/_thread.rst:155
msgid ""
"The maximum value allowed for the *timeout* parameter of :meth:`Lock.acquire "
"<threading.Lock.acquire>`. Specifying a timeout greater than this value will "
"raise an :exc:`OverflowError`."
msgstr ""
"O valor máximo permitido para o parâmetro *timeout* de :meth:`Lock.acquire "
"<threading.Lock.acquire>`. A especificação de um tempo limite maior que esse "
"valor vai levantar um :exc:`OverflowError`."

#: ../../library/_thread.rst:162
msgid "Lock objects have the following methods:"
msgstr "Os objetos de trava têm os seguintes métodos:"

#: ../../library/_thread.rst:167
msgid ""
"Without any optional argument, this method acquires the lock "
"unconditionally, if necessary waiting until it is released by another thread "
"(only one thread at a time can acquire a lock --- that's their reason for "
"existence)."
msgstr ""
"Sem nenhum argumento opcional, esse método adquire a trava "
"incondicionalmente, se necessário, aguardando até que seja liberada por "
"outra thread (apenas uma thread por vez pode adquirir uma trava --- esse é o "
"motivo da sua existência)."

#: ../../library/_thread.rst:171
msgid ""
"If the *blocking* argument is present, the action depends on its value: if "
"it is false, the lock is only acquired if it can be acquired immediately "
"without waiting, while if it is true, the lock is acquired unconditionally "
"as above."
msgstr ""
"Se o argumento inteiro *blocking* estiver presente, a ação dependerá do seu "
"valor: se for falso, a trava será adquirida apenas se puder ser adquirida "
"imediatamente sem aguardar, enquanto se for verdadeiro, a trava será "
"adquirida incondicionalmente, conforme acima."

#: ../../library/_thread.rst:176
msgid ""
"If the floating-point *timeout* argument is present and positive, it "
"specifies the maximum wait time in seconds before returning.  A negative "
"*timeout* argument specifies an unbounded wait.  You cannot specify a "
"*timeout* if *blocking* is false."
msgstr ""
"Se o argumento de ponto flutuante *timeout* estiver presente e positivo, ele "
"especificará o tempo máximo de espera em segundos antes de retornar. Um "
"argumento negativo *timeout* especifica uma espera ilimitada. Você não pode "
"especificar um *timeout* se *blocking* for falso."

#: ../../library/_thread.rst:181
msgid ""
"The return value is ``True`` if the lock is acquired successfully, ``False`` "
"if not."
msgstr ""
"O valor de retorno é ``True`` se a trava for adquirida com sucesso, se não "
"``False``."

#: ../../library/_thread.rst:184
msgid "The *timeout* parameter is new."
msgstr "O parâmetro *timeout* é novo."

#: ../../library/_thread.rst:187
msgid "Lock acquires can now be interrupted by signals on POSIX."
msgstr ""
"As aquisições de trava agora podem ser interrompidas por sinais no POSIX."

#: ../../library/_thread.rst:193
msgid ""
"Releases the lock.  The lock must have been acquired earlier, but not "
"necessarily by the same thread."
msgstr ""
"Libera a trava. A trava deve ter sido adquirido anteriormente, mas não "
"necessariamente pela mesma thread."

#: ../../library/_thread.rst:199
msgid ""
"Return the status of the lock: ``True`` if it has been acquired by some "
"thread, ``False`` if not."
msgstr ""
"Retorna o status da trava: ``True`` se tiver sido adquirida por alguma "
"thread, ``False`` se não for o caso."

#: ../../library/_thread.rst:202
msgid ""
"In addition to these methods, lock objects can also be used via the :keyword:"
"`with` statement, e.g.::"
msgstr ""
"Além desses métodos, os objetos de trava também podem ser usados através da "
"instrução :keyword:`with`, por exemplo::"

#: ../../library/_thread.rst:205
msgid ""
"import _thread\n"
"\n"
"a_lock = _thread.allocate_lock()\n"
"\n"
"with a_lock:\n"
"    print(\"a_lock is locked while this executes\")"
msgstr ""
"import _thread\n"
"\n"
"uma_trava = _thread.allocate_lock()\n"
"\n"
"with uma_trava:\n"
"    print(\"uma_trava está travada enquanto isto executa\")"

#: ../../library/_thread.rst:212
msgid "**Caveats:**"
msgstr "**Ressalvas:**"

#: ../../library/_thread.rst:216
msgid ""
"Interrupts always go to the main thread (the :exc:`KeyboardInterrupt` "
"exception will be received by that thread.)"
msgstr ""
"Interrupções sempre vão para a thread principal (a exceção :exc:"
"`KeyboardInterrupt` será recebida por essa thread)."

#: ../../library/_thread.rst:219
msgid ""
"Calling :func:`sys.exit` or raising the :exc:`SystemExit` exception is "
"equivalent to calling :func:`_thread.exit`."
msgstr ""
"Chamar :func:`sys.exit` ou levantar a exceção :exc:`SystemExit` é o "
"equivalente a chamar :func:`_thread.exit`."

#: ../../library/_thread.rst:222
msgid ""
"It is platform-dependent whether the :meth:`~threading.Lock.acquire` method "
"on a lock can be interrupted (so that the :exc:`KeyboardInterrupt` exception "
"will happen immediately, rather than only after the lock has been acquired "
"or the operation has timed out). It can be interrupted on POSIX, but not on "
"Windows."
msgstr ""
"O método :meth:`~threading.Lock.acquire` de uma trava ser interrompido "
"depende da plataforma (de modo que a exceção :exc:`KeyboardInterrupt` "
"acontecerá imediatamente, em vez de quando a trava for travada, ou quando a "
"operação ultrapassar o tempo limite). O método pode ser interrompido em "
"POSIX, mas não em Windows."

#: ../../library/_thread.rst:228
msgid ""
"When the main thread exits, it is system defined whether the other threads "
"survive.  On most systems, they are killed without executing :keyword:"
"`try` ... :keyword:`finally` clauses or executing object destructors."
msgstr ""
"Quando a thread principal se encerra, o fato de outras threads sobreviverem "
"depende do sistema. Na maioria dos sistemas, elas são eliminadas sem "
"executar cláusulas :keyword:`try` ... :keyword:`finally` ou destruidores de "
"objetos."

#: ../../library/_thread.rst:7
msgid "light-weight processes"
msgstr "processos leves"

#: ../../library/_thread.rst:7
msgid "processes, light-weight"
msgstr "leves, processos"

#: ../../library/_thread.rst:7
msgid "binary semaphores"
msgstr "semáforos binários"

#: ../../library/_thread.rst:7
msgid "semaphores, binary"
msgstr "binários, semáforos"

#: ../../library/_thread.rst:22
msgid "pthreads"
msgstr "pthreads"

#: ../../library/_thread.rst:22
msgid "threads"
msgstr "threads"

#: ../../library/_thread.rst:22
msgid "POSIX"
msgstr "POSIX"

#: ../../library/_thread.rst:214
msgid "module"
msgstr "módulo"

#: ../../library/_thread.rst:214
msgid "signal"
msgstr "signal"