JavaScript Academy · Aula

Casos de uso e limitações

Saiba quando os workers ajudam e o que não podem fazer.

Casos de uso e limitações é uma aula grátis de JavaScript Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de JavaScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de JavaScript Academy inclui 4 aulas no total.

Para que os worker são adequados

Os worker da Web são excelentes quando você tem um trabalho que exige muito da CPU e que, de outra forma, congelaria a interface:

Processamento de imagens e vídeos
Análise de arquivos grandes (CSV, JSON)
Criptografia e cálculo de hash
Física, análise de dados e simulações

Sem acesso ao DOM

A maior limitação: os worker não podem acessar o DOM. Não há document nem window. Eles calculam os dados e os enviam de volta; a linha de execução principal atualiza a interface.

// Inside a worker:
// document.querySelector(...) -> ReferenceError
// Workers have no DOM at all.

O que IS disponibiliza

Os worker ainda têm acesso a muitas APIs úteis: fetch, setTimeout, WebSocket, IndexedDB, crypto e matrizes tipadas. Portanto, a busca e o armazenamento de dados funcionam bem fora da linha de execução principal.

// Inside a worker this is valid:
// const res = await fetch('/data.json');
// const json = await res.json();
// self.postMessage(json);

Limitações da clonagem estruturada

Lembre-se de que as mensagens são copiadas por clonagem estruturada. Você não pode enviar funções, nós do DOM ou instâncias de classes com métodos, apenas seus dados serializáveis.

// Cannot be sent:
// worker.postMessage(() => {});      // function - fails
// worker.postMessage(document.body); // DOM node - fails

Custo de inicialização e de mensagens

Criar um worker e serializar mensagens tem um custo adicional. Para tarefas muito pequenas, o custo da troca de mensagens pode superar o benefício. Os worker compensam quando o trabalho é substancial e contínuo.

Mantendo os worker ativos

Criar um novo worker para cada tarefa é ineficiente. Reutilize um worker de longa duração e envie muitas mensagens a ele, ou mantenha um pequeno conjunto de workers para obter paralelismo.

// Reuse one worker for many tasks:
const worker = new Worker('worker.js');
function run(task) {
  worker.postMessage(task);
}
// Avoid: new Worker(...) on every single call.

Conjuntos de workers

Para usar vários núcleos da CPU, crie vários workers e distribua as tarefas entre eles. Acompanhe quais estão ociosos e atribua o trabalho recebido aos que estiverem livres.

const pool = [];
for (let i = 0; i < 4; i++) {
  pool.push(new Worker('worker.js'));
}
// Round-robin or queue tasks across the pool.

Compartilhando memória

Em casos avançados, SharedArrayBuffer permite que as linhas de execução compartilhem memória diretamente (com Atomics para acesso seguro). Esse recurso exige cabeçalhos especiais de isolamento entre origens e é fácil de usar incorretamente.

// Requires COOP/COEP headers to be enabled.
// const shared = new SharedArrayBuffer(1024);
// Atomics.add(view, 0, 1); // safe concurrent update

Isolamento de erros

Um erro não tratado em um worker não encerra a página. Ele aparece como um evento error no worker, que você deve tratar para registrar o erro ou reiniciar o worker.

worker.onerror = (e) => {
  console.log('worker failed:', e.message);
  // optionally recreate the worker here
};

Quando NÃO usar workers

Evite workers quando a tarefa for trivial, exigir atualizações constantes do DOM ou consistir principalmente em esperar pela rede (o fetch assíncrono já não bloqueia). Use-os para trabalhos genuinamente limitados pela CPU.

Reunindo tudo

Os worker da Web trocam o acesso direto ao DOM e o compartilhamento fácil de dados por paralelismo real. Use-os para cálculos pesados, comunique-se por mensagens, reutilize os worker e transfira buffers grandes para manter seu aplicativo rápido e fluido.

Verificação rápida

Teste sua compreensão sobre casos de uso e limitações de workers.

Recapitulação

Você aprendeu sobre casos de uso e limitações de workers:

São excelentes para trabalhos que exigem muito da CPU, mas não têm acesso ao DOM.
Muitas APIs (fetch, IndexedDB, crypto) estão disponíveis.
As mensagens passam por clonagem estruturada, portanto não podem conter funções nem nós do DOM.
Reutilize workers ou conjuntos de workers para diluir o custo de inicialização.
Os erros permanecem isolados no worker.

Você concluiu o módulo sobre worker da Web. A seguir, IndexedDB.

Perguntas Frequentes

A aula “Casos de uso e limitações” é grátis?

Sim — o texto completo de “Casos de uso e limitações” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de JavaScript Academy, atualize para CoddyKit PRO. O curso de JavaScript Academy inclui 4 aulas no total.

O que vou aprender em “Casos de uso e limitações”?

Saiba quando os workers ajudam e o que não podem fazer. Você pratica JavaScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar JavaScript Academy?

Nenhuma experiência prévia é necessária. JavaScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Casos de uso e limitações”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de JavaScript Academy?

Sim. Cada aula de JavaScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para JavaScript Academy