Processos Filhos
Em Node.js, Processos Filhos (Child Processes) são processos independentes que podem ser executados em paralelo ao processo principal sem bloquear o Event Loop. Eles permitem que tarefas pesadas, como cálculos complexos, processamento de grandes volumes de dados ou execução de múltiplas tarefas simultâneas, sejam realizadas de forma eficiente e escalável.
Node.js oferece métodos como fork, spawn e exec para criar Processos Filhos, que podem se comunicar com o processo principal usando comunicação interprocessual (IPC). Compreender a sintaxe do Node.js, estruturas de dados, algoritmos e princípios de POO é fundamental para implementar Processos Filhos de forma eficaz e segura.
Neste tutorial, você aprenderá a criar Processos Filhos, enviar e receber mensagens entre processos, gerenciar erros e executar tarefas pesadas de forma assíncrona. Ao final, você será capaz de aplicar Processos Filhos em projetos reais de Node.js para melhorar a performance, a escalabilidade e a modularidade de suas aplicações.
Exemplo Básico
textconst { fork } = require('child_process');
// Criando um Processo Filho simples
const child = fork('./taskChild.js');
// Enviando mensagem do processo principal para o filho
child.send({ task: 'sumCalculate', numbers: [1, 2, 3, 4, 5] });
// Recebendo mensagem do processo filho
child.on('message', (result) => {
console.log('Resultado do processo filho:', result);
});
// Tratamento de erros
child.on('error', (err) => {
console.error('Erro no processo filho:', err);
});
// taskChild.js
process.on('message', (msg) => {
const sum = msg.numbers.reduce((a, b) => a + b, 0);
process.send(sum);
});Neste exemplo, usamos fork para criar um Processo Filho que executa o arquivo taskChild.js. O processo filho recebe dados enviados pelo processo principal, realiza o cálculo da soma usando o método reduce e envia o resultado de volta.
A comunicação é realizada com child.send e process.on('message'), garantindo troca segura de dados entre processos. O evento error permite capturar exceções no processo filho sem afetar o processo principal. Este exemplo demonstra a estrutura básica, modularidade e boas práticas de Processos Filhos em Node.js, preparando o caminho para implementações mais complexas.
Exemplo Prático
textconst { fork } = require('child_process');
const path = require('path');
const tasks = ['task1', 'task2', 'task3'];
const results = [];
tasks.forEach((taskName, index) => {
const child = fork(path.join(__dirname, 'worker.js'));
child.send({ task: taskName, data: Array.from({ length: 1000 }, (_, i) => i + 1) });
child.on('message', (result) => {
results[index] = result;
console.log(`Processo filho ${taskName} concluído:`, result);
if (results.filter(Boolean).length === tasks.length) {
console.log('Todos os Processos Filhos concluídos:', results);
}
});
child.on('error', (err) => {
console.error(`Erro no processo filho ${taskName}:`, err);
});
});
// worker.js
process.on('message', (msg) => {
const sum = msg.data.reduce((acc, val) => acc + val, 0);
process.send(sum);
});Este exemplo avançado demonstra execução paralela de múltiplos Processos Filhos. Cada processo processa dados independentemente e envia resultados ao processo principal. O uso do reduce otimiza cálculos, e a separação da lógica em worker.js facilita manutenção e legibilidade. O tratamento de erros individual garante que falhas em um processo não afetem os demais, tornando o padrão aplicável em sistemas complexos de Node.js para processamento paralelo e tarefas intensivas.
Boas práticas incluem limitar o número de Processos Filhos simultâneos, tratar erros de forma completa, otimizar o uso de memória e reutilizar processos sempre que possível. Erros comuns incluem não tratar exceções, deixar processos inativos causando vazamentos de memória e algoritmos ineficientes. Para depuração, recomenda-se logging estruturado e rastreamento das mensagens entre processos. Otimizações incluem uso de process pools e algoritmos assíncronos. Em termos de segurança, validar dados de entrada e evitar execução de código não confiável é essencial.
📊 Tabela de Referência
| Node.js Element/Concept | Description | Usage Example |
|---|---|---|
| fork | Cria um processo filho independente | const child = fork('./worker.js'); |
| process.send | Envia dados para o processo filho | child.send({ task: 'sum', numbers: [1,2,3] }); |
| child.on('message') | Recebe mensagens do processo filho | child.on('message', msg => console.log(msg)); |
| child.on('error') | Gerencia erros no processo filho | child.on('error', err => console.error(err)); |
| reduce | Cálculo de agregação de arrays | const sum = data.reduce((a,b)=>a+b,0); |
Processos Filhos em Node.js permitem execução paralela sem bloquear o Event Loop principal. Aprender a criar, comunicar, tratar erros e otimizar Processos Filhos é crucial para aplicações escaláveis e de alto desempenho. Próximos passos incluem estudar process pools, o módulo cluster e padrões avançados de programação assíncrona. Recursos adicionais incluem a documentação oficial do Node.js, projetos open-source e boas práticas da comunidade.
🧠 Teste Seu Conhecimento
Teste Seu Conhecimento
Desafie-se com este questionário interativo e veja o quão bem você entende o tópico
📝 Instruções
- Leia cada pergunta cuidadosamente
- Selecione a melhor resposta para cada pergunta
- Você pode refazer o quiz quantas vezes quiser
- Seu progresso será mostrado no topo