Lição 41: Threads e Join (Operações Simultâneas)

1. Narrativa

O mecha Æther possui múltiplos núcleos de processamento capazes de executar operações simultaneamente. Enquanto um braço recalibra o canhão, o outro escaneia o terreno. Threads são como esses braços independentes — cada um executa sua tarefa em paralelo, e o piloto coordena tudo com join(), esperando cada operação terminar antes de prosseguir.

2. Conceito

Threads permitem execução concorrente em Rust:

• std::thread::spawn: Cria uma nova thread que executa um closure
• JoinHandle::join(): Bloqueia até a thread terminar, retorna Result<T>
• Closures move: Transferem ownership de variáveis para a thread
• thread::sleep: Pausa a thread por uma duração
• Segurança: O borrow checker garante que não há data races em tempo de compilação

3. Requisitos

• Usar std::thread::spawn para criar threads
• Usar join() para esperar a conclusão das threads
• Usar closures move para transferir dados
• Coordenar múltiplas threads em paralelo

4. Design de Dados

graph LR
    A[Thread Principal] --> B[thread::spawn]
    B --> C[Thread 1]
    A --> D[thread::spawn]
    D --> E[Thread 2]
    C --> F[join]
    E --> F
    F --> G[Resultado combinado]

5. Diagrama de Fluxo

flowchart TD
    A[Início] --> B[Criar Thread 1]
    A --> C[Criar Thread 2]
    B --> D[Thread 1 executa]
    C --> E[Thread 2 executa]
    D --> F[join Thread 1]
    E --> G[join Thread 2]
    F --> H[Combinar resultados]
    G --> H
    H --> I[Fim]

6. Funções

Função	Descrição
processar_em_thread	Dobra valores em uma thread separada
duas_threads	Executa duas tarefas em paralelo
contar_em_thread	Conta elementos acima do limiar via thread
juntar_threads	Processa múltiplos grupos em threads e concatena
buscar_em_thread	Busca valor em uma thread
maiusculas_thread	Converte strings para maiúsculas via thread
soma_paralela	Soma dois grupos em threads separadas
contar_threads	Conta threads que completaram com sucesso

7. Exemplo

use std::thread;

let handle = thread::spawn(move || {
    dados.iter().map(|x| x * 2).collect::<Vec<_>>()
});
let resultado = handle.join().unwrap();

8. Missão

1. Implementar processar_em_thread com thread::spawn e join
2. Implementar duas_threads criando duas threads e juntando os resultados
3. Implementar contar_em_thread filtrando valores em thread
4. Implementar juntar_threads processando grupos em threads separadas
5. Implementar buscar_em_thread procurando valor em thread
6. Implementar maiusculas_thread transformando strings em thread
7. Implementar soma_paralela somando em duas threads
8. Implementar contar_threads criando N threads e contando sucessos

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• Sempre use move antes do closure para transferir ownership
• join() retorna Result<T, Box<dyn Any>> — use unwrap() ou expect()
• Threads não podem borrow variáveis do escopo pai sem move
• O número ideal de threads depende do número de núcleos do processador
• Use thread::available_parallelism() para descobrir o número de núcleos