Aplicações modernas raramente executam apenas uma tarefa por vez. Servidores web atendem milhares de usuários simultaneamente, sistemas financeiros processam diversas transações em paralelo, pipelines de dados manipulam grandes volumes de informações e aplicações de Inteligência Artificial realizam múltiplas operações concorrentes.
Para lidar com esses cenários, Python oferece diferentes modelos de concorrência, cada um projetado para resolver tipos específicos de problemas.
Neste módulo estudaremos os principais mecanismos de concorrência disponíveis no ecossistema Python.
Mais do que aprender a utilizar cada ferramenta, o objetivo é compreender quando utilizá-las, por que elas existem e quais são seus impactos no desempenho, consumo de memória e escalabilidade das aplicações.
Ao final deste módulo, você será capaz de escolher a estratégia de concorrência mais adequada para diferentes tipos de problemas encontrados no desenvolvimento profissional.
Ao concluir este módulo, você será capaz de:
- compreender os conceitos de concorrência e paralelismo;
- identificar a diferença entre tarefas CPU-bound e I/O-bound;
- desenvolver aplicações utilizando programação assíncrona;
- criar aplicações concorrentes com threads;
- utilizar múltiplos processos para processamento paralelo;
- compreender o funcionamento do Global Interpreter Lock (GIL);
- escolher a melhor abordagem para cada cenário;
- desenvolver aplicações mais eficientes e escaláveis.
Concorrência é a capacidade de uma aplicação lidar com várias tarefas ao mesmo tempo, alternando sua execução de forma eficiente.
É importante diferenciar dois conceitos frequentemente confundidos:
Diversas tarefas fazem progresso durante o mesmo período, mas nem sempre executam exatamente no mesmo instante.
Tarefa A
↓
Tarefa B
↓
Tarefa A
↓
Tarefa C
Diversas tarefas realmente executam simultaneamente em diferentes núcleos do processador.
CPU 1 → Tarefa A
CPU 2 → Tarefa B
CPU 3 → Tarefa C
Todo paralelismo é concorrência, mas nem toda concorrência é paralelismo.
A escolha do modelo de concorrência depende principalmente do tipo de tarefa.
São tarefas limitadas pelo poder de processamento da CPU.
Exemplos:
- algoritmos matemáticos;
- criptografia;
- processamento de imagens;
- renderização;
- compressão de arquivos;
- treinamento de modelos de IA.
Melhor abordagem:
- Multiprocessing
São tarefas que passam grande parte do tempo aguardando respostas de recursos externos.
Exemplos:
- chamadas para APIs;
- consultas ao banco de dados;
- leitura e escrita de arquivos;
- comunicação em rede;
- WebSockets.
Melhores abordagens:
- AsyncIO
- Threading
Este módulo é dividido em quatro tópicos principais.
- Threading
- Multiprocessing
- Asynchrony
- Global Interpreter Lock (GIL)
T| Tecnologia | Melhor para | Utiliza múltiplos núcleos? | Compartilha memória? | | --------------- | ----------------------------------- | -------------------------------------- | ---------------------------------------------- | | AsyncIO | Operações I/O assíncronas | Não | Sim (uma thread principal) | | Threading | Operações I/O bloqueantes | Não (para código Python devido ao GIL) | Sim | | Multiprocessing | Processamento intensivo (CPU-bound) | Sim | Não (cada processo possui sua própria memória) |
Ao concluir este módulo, você será capaz de:
- desenvolver aplicações concorrentes;
- utilizar
asynciode forma eficiente; - criar aplicações multithread;
- utilizar múltiplos processos para processamento paralelo;
- sincronizar acesso a recursos compartilhados;
- evitar condições de corrida;
- identificar gargalos de desempenho;
- selecionar corretamente entre
asyncio,threadingemultiprocessing; - compreender como o GIL influencia o comportamento do Python.
Os conceitos estudados neste módulo são amplamente utilizados em diversas áreas da indústria.
- Desenvolvimento Web
- Microsserviços
- Engenharia de Dados
- Ciência de Dados
- Inteligência Artificial
- Automação
- Internet das Coisas (IoT)
A escolha depende da natureza do problema.
| Situação | Melhor escolha |
|---|---|
| Muitas chamadas para APIs | AsyncIO |
| Comunicação com banco de dados | AsyncIO ou Threading |
| Download simultâneo de arquivos | Threading ou AsyncIO |
| Processamento matemático intenso | Multiprocessing |
| Compressão de arquivos | Multiprocessing |
| Processamento de imagens | Multiprocessing |
| Servidores Web modernos | AsyncIO |
| Bibliotecas síncronas que bloqueiam | Threading |
Não existe uma solução universal. Em muitos sistemas reais, diferentes modelos de concorrência podem coexistir, cada um sendo utilizado na parte da aplicação em que oferece mais vantagens.
Antes de iniciar este módulo, recomenda-se conhecer:
- sintaxe da linguagem Python;
- funções;
- exceções;
- módulos e pacotes;
- estruturas de dados;
- Programação Orientada a Objetos;
- noções básicas de sistemas operacionais (processos e memória).
Após dominar concorrência em Python, você estará preparado para estudar tópicos mais avançados, como programação distribuída, filas de mensagens, computação em nuvem, arquiteturas de microsserviços, processamento paralelo em clusters, computação de alto desempenho (HPC), frameworks distribuídos e otimização de aplicações escaláveis.
O módulo Concurrency apresenta os principais modelos de concorrência disponíveis em Python e ensina como utilizá-los de forma eficiente em aplicações reais. Ao longo do módulo, você compreenderá os fundamentos da programação assíncrona com AsyncIO, o uso de Threads para tarefas de entrada e saída, a utilização de Multiprocessing para explorar múltiplos núcleos da CPU e o impacto do Global Interpreter Lock (GIL) no interpretador CPython. Com esse conhecimento, será possível analisar a natureza de um problema, identificar se ele é CPU-bound ou I/O-bound e selecionar a estratégia mais adequada para construir aplicações modernas, eficientes e escaláveis.