O módulo threading em Python fornece uma interface de alto nível para criar e gerenciar threads, permitindo que você execute código simultaneamente. Isso pode ser especialmente útil para tarefas que podem ser executadas em paralelo, como operações vinculadas a E/S. Abaixo está uma lista de métodos e funções comumente usados no módulo threading, com breves exemplos.
A classe Thread é o coração do módulo threading. Você pode criar e iniciar novos tópicos usando esta classe.
import threading def print_numbers(): for i in range(5): print(i) t = threading.Thread(target=print_numbers) t.start() # Starts a new thread t.join() # Waits for the thread to finish
Inicia a atividade do tópico.
t = threading.Thread(target=print_numbers) t.start() # Runs the target function in a separate thread
Bloqueia o thread de chamada até que o thread cujo método join() é chamado termine. Opcionalmente, você pode especificar um tempo limite.
t = threading.Thread(target=print_numbers) t.start() t.join(2) # Waits up to 2 seconds for the thread to finish
Retorna True se o thread ainda estiver em execução.
t = threading.Thread(target=print_numbers) t.start() print(t.is_alive()) # True if the thread is still running
Retorna o objeto Thread atual, representando o thread de chamada.
import threading def print_current_thread(): print(threading.current_thread()) t = threading.Thread(target=print_current_thread) t.start() # Prints the current thread info
Retorna uma lista de todos os objetos Thread atualmente ativos.
t1 = threading.Thread(target=print_numbers) t2 = threading.Thread(target=print_numbers) t1.start() t2.start() print(threading.enumerate()) # Lists all active threads
Retorna o número de objetos Thread atualmente ativos.
print(threading.active_count()) # Returns the number of active threads
Um objeto Lock é um bloqueio primitivo usado para evitar condições de corrida. Você pode usá-lo para garantir que apenas um thread acesse um recurso compartilhado por vez.
lock = threading.Lock() def thread_safe_function(): with lock: # Acquires the lock # Critical section print("Thread-safe code") t = threading.Thread(target=thread_safe_function) t.start()
Um bloqueio reentrante permite que um thread adquira() o bloqueio várias vezes sem bloquear a si mesmo.
lock = threading.RLock() def reentrant_function(): with lock: with lock: # Same thread can acquire the lock again print("Reentrant lock example") t = threading.Thread(target=reentrant_function) t.start()
Um objeto Condition permite que threads esperem que alguma condição seja atendida.
condition = threading.Condition() def thread_wait(): with condition: condition.wait() # Wait for the condition print("Condition met") def thread_notify(): with condition: condition.notify() # Notify the waiting thread t1 = threading.Thread(target=thread_wait) t2 = threading.Thread(target=thread_notify) t1.start() t2.start()
Um objeto Event é usado para sinalizar entre threads. Um thread pode esperar que um evento seja definido e outro thread pode definir o evento.
event = threading.Event() def wait_for_event(): event.wait() # Wait until the event is set print("Event has been set") t = threading.Thread(target=wait_for_event) t.start() event.set() # Set the event to allow the thread to continue
Um objeto Semaphore permite limitar o número de threads que podem acessar um recurso simultaneamente.
semaphore = threading.Semaphore(2) # Only 2 threads can access the resource at once def access_resource(): with semaphore: print("Resource accessed") t1 = threading.Thread(target=access_resource) t2 = threading.Thread(target=access_resource) t3 = threading.Thread(target=access_resource) t1.start() t2.start() t3.start()
Um thread Timer executa uma função após um intervalo especificado.
def delayed_function(): print("Executed after delay") timer = threading.Timer(3, delayed_function) timer.start() # Executes `delayed_function` after 3 seconds
Threads daemon são executados em segundo plano e saem automaticamente quando o programa principal é encerrado. Você pode transformar um thread em um daemon chamando setDaemon(True) ou passando daemon=True para o construtor Thread.
t = threading.Thread(target=print_numbers, daemon=True) t.start() # Daemon thread will exit when the main program ends
O módulo threading é uma ferramenta poderosa para lidar com simultaneidade em Python. Ele fornece várias classes e métodos para criar e controlar threads, facilitando a execução de código em paralelo. Desde o uso de objetos Thread básicos até o gerenciamento da sincronização com Lock e Semaphore, este módulo é essencial para escrever programas Python simultâneos.
Isenção de responsabilidade: Todos os recursos fornecidos são parcialmente provenientes da Internet. Se houver qualquer violação de seus direitos autorais ou outros direitos e interesses, explique os motivos detalhados e forneça prova de direitos autorais ou direitos e interesses e envie-a para o e-mail: [email protected]. Nós cuidaremos disso para você o mais rápido possível.
Copyright© 2022 湘ICP备2022001581号-3