Summary
This chapter covers creating and managing threads using Python’s threading module—including starting, joining, and synchronizing access to shared data with locks to prevent race conditions.

General domain of usage
I/O-bound operations


Imagine a kitchen as your Python process: it's the environment where all the action happens. Inside this kitchen, chefs represent threads—each chef is a worker, carrying out specific tasks. The fridge and counter are like your shared memory (RAM), where all chefs can reach for ingredients or place finished dishes. This is how threads in Python share data—they all work in the same space and can access the same resources.

When you run multiple threads, it's like having a team of chefs in the same kitchen. If one chef is waiting for the oven (an I/O bound operation), another can chop vegetables or start a new dish. This is concurrency: tasks overlap in time, making the kitchen more efficient.

However, there's a special rule in Python called the Global Interpreter Lock, or GIL. Think of the GIL as the 'Master Knife'—only one chef can use it at any moment. Chefs must pass the knife between them quickly, so it looks like they're all working at once. In reality, only one chef is actively preparing food with the knife at any given time. This means threads take turns running Python code, even though they share the kitchen.

Let's tie this back to the threading code example. When you create two threads, it's like hiring two chefs. Each chef has a name, so you can tell who is doing what. The 'start' method signals both chefs to begin working, and 'join' waits for both to finish before you close the kitchen. If both chefs need the fridge at the same time, you use a lock—like a kitchen rule—to make sure they don't collide or spoil the ingredients. This way, your kitchen (process) stays organized, and your chefs (threads) can work together safely and efficiently.. In video use code samples with 9 code lines maximum and one sample at each slide.

O módulo `threading` do Python oferece uma maneira simples e poderosa de criar e gerenciar threads, permitindo a execução de múltiplas operações concorrentemente dentro de um único processo. As threads são unidades leves de execução que compartilham o mesmo espaço de memória, tornando-as adequadas para tarefas como operações de I/O, espera por recursos externos ou atualização de interfaces de usuário.

O ciclo de vida de uma thread normalmente envolve várias etapas:  
- Criação: um objeto thread é instanciado, mas ainda não iniciado;  
- Inicialização: o método `start()` da thread é chamado, movendo-a para o estado pronto para execução;  
- Execução: a thread executa sua função alvo;  
- Finalização: a thread termina a execução, seja ao concluir sua tarefa ou ao encontrar uma exceção não tratada.



O gerenciamento de threads exige atenção cuidadosa à **sincronização**, já que as threads compartilham dados e recursos. Sem a sincronização adequada, podem ocorrer **condições de corrida** ou estados inconsistentes. O módulo `threading` oferece primitivas como `Lock`, `RLock` e `Event` para ajudar a coordenar o acesso das threads a recursos compartilhados.

 

A seguir, uma tabela apresenta funções que auxiliam na criação, gerenciamento e sincronização de threads de forma eficaz ao trabalhar com tarefas concorrentes em Python.

Creates a new thread object; pass a target function and arguments.

Begins execution of the thread; runs the target function in a new thread. 

Waits for the thread to finish before continuing execution.

Adds a thread object to a list; used to collect multiple threads so they can be managed as a group.

Returns the currently executing thread object. 

Creates a lock object for synchronizing access to shared resources.

Creates a re-entrant lock, allowing the same thread to acquire it multiple times.

Creates an event object for signaling between threads.

Sets or gets the thread's name for easier identification


O exemplo a seguir demonstra como criar e iniciar múltiplas threads utilizando o módulo `threading`, permitindo que várias tarefas sejam executadas concorrentemente.

import threading
import time

def print_numbers(name):
    for i in range(1, 4):
        print(f"Thread {name}: {i}")
        time.sleep(0.5)

# Create thread objects
thread1 = threading.Thread(target=print_numbers, args=("A",))
thread2 = threading.Thread(target=print_numbers, args=("B",))

# Start the threads
thread1.start()
thread2.start()

# Wait for both threads to finish
thread1.join()
thread2.join()

print("Both threads have finished.")

Você define uma função, `print_numbers`, que imprime uma sequência de números junto com o nome da thread. Ao criar cada thread, você passa argumentos usando o parâmetro `args` – aqui, cada thread recebe um nome diferente ("A" ou "B"), facilitando a distinção das saídas. Ao chamar o método `start()`, ambas as threads iniciam a execução e rodam concorrentemente. A chamada `time.sleep(0.5)` dentro do loop simula um atraso na execução, permitindo que as threads intercalem suas saídas e tornando fácil perceber que ambas estão rodando ao mesmo tempo. O método `join()` é então utilizado para aguardar a finalização das duas threads antes de prosseguir, garantindo que o programa principal não termine prematuramente. Essa abordagem permite que tarefas sejam executadas em paralelo, aproveitando de forma eficiente os tempos de espera e possibilitando a execução concorrente dentro de um único processo.

Qual das seguintes afirmações sobre sincronização de threads em Python está correta?

Uma análise aprofundada de conceitos avançados de programação estrutural em Python, com foco em manipulação robusta de arquivos, gerenciamento de erros, concorrência, programação assíncrona e testes.

Domine o sistema de exceções do Python para tratamento de erros robusto e depuração.

Explore técnicas avançadas para operações de arquivos e gerenciamento de recursos utilizando gerenciadores de contexto.

Comparação e aplicação dos módulos de multithreading e multiprocessing do Python para programação concorrente.

Domine a programação assíncrona em Python utilizando a biblioteca asyncio para aplicações escaláveis orientadas a I/O.

Explore como escrever, organizar e executar testes utilizando os frameworks unittest e pytest do Python.

Trabalhando com Threads