Fundamentos de Threads

Uma thread representa um caminho de execução independente dentro de um programa. Cada bifurcação de execução constitui uma thread distinta. Enquanto processos são entidades estáticas (como arquivos .class ou .exe), a execução real ocorre através de threads. Sistemas operacionais modernos gerenciam múltiplos processos e threads simultaneamente.

A CPU executa threads através de time-slicing: divide seu tempo em intervalos mínimos, alternando rapidamente entre threads. Apesar da aparente simultaneidade, um núcleo de CPU processa apenas uma thread por instante. Paralelismo real só ocorre com múltiplos núcleos ou CPUs.

Criação e Inicialização de Threads

Implementando Runnable

public class ExemploRunnable {
    public static void main(String[] args) {
        Tarefa tarefa = new Tarefa();
        Thread novaThread = new Thread(tarefa);
        novaThread.start();
        
        for(int contador = 0; contador < 100; contador++) {
            System.out.println("Thread Principal: " + contador);
        }
    }
}

class Tarefa implements Runnable {
    public void run() {
        for(int contador = 0; contador < 100; contador++) {
            System.out.println("Thread Secundária: " + contador);
        }
    }
}

Estendendo Thread

public class ExemploHeranca {
    public static void main(String[] args) {
        MinhaThread thread = new MinhaThread();
        thread.start();
        
        for(int contador = 0; contador < 100; contador++) {
            System.out.println("Thread Principal: " + contador);
        }
    }
}

class MinhaThread extends Thread {
    public void run() {
        for(int contador = 0; contador < 100; contador++) {
            System.out.println("Thread Filha: " + contador);
        }
    }
}

Estados de Thread

Após criação (new Thread()), uma thread entra em estado pronta. Quando escalonada pela CPU, muda para executando. Durante a execução, pode ser interromipda e entrar em estado bloqueada, retornando posteriomrente ao estado pronta. Ao concluir sua execução, atinge o estado terminada.

Controle de Threads

Métodos Essenciais

• isAlive(): Verifica se a thread está ativa
• setPriority()/getPriority(): Gerencia prioridade (1-10)
• Thread.sleep(): Suspende a execução temporariamente
• join(): Aguarda término de outra thread
• yield(): Libera voluntariamente a CPU

Exemplo de Sleep e Interrupção

public class ExemploInterrupcao {
    public static void main(String[] args) throws InterruptedException {
        Temporizador temporizador = new Temporizador();
        temporizador.start();
        Thread.sleep(5000);
        temporizador.interrupt();
    }
}

class Temporizador extends Thread {
    public void run() {
        while(!isInterrupted()) {
            System.out.println("Horário: " + new Date());
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                interrupt();
            }
        }
    }
}

Exemplo de Join

public class ExemploJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread secundaria = new Thread(() -> {
            for(int i=0; i<5; i++) {
                System.out.println("Thread Secundária executando");
            }
        });
        
        secundaria.start();
        secundaria.join();
        System.out.println("Thread Principal concluída após join");
    }
}

Exemplo de Yield

public class ExemploYield {
    public static void main(String[] args) {
        new Thread(new TarefaYield(), "Thread A").start();
        new Thread(new TarefaYield(), "Thread B").start();
    }
}

class TarefaYield implements Runnable {
    public void run() {
        for(int i=1; i<=50; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);
            if(i % 5 == 0) Thread.yield();
        }
    }
}

Gerenciamento de Prioridades

public class ExemploPrioridade {
    public static void main(String[] args) {
        Thread baixaPrioridade = new Thread(() -> executarTarefa("Baixa"));
        Thread altaPrioridade = new Thread(() -> executarTarefa("Alta"));
        
        baixaPrioridade.setPriority(Thread.MIN_PRIORITY);
        altaPrioridade.setPriority(Thread.MAX_PRIORITY);
        
        baixaPrioridade.start();
        altaPrioridade.start();
    }
    
    private static void executarTarefa(String nome) {
        for(int i=0; i<200; i++) {
            System.out.println(nome + ": " + i);
        }
    }
}