Threads são fluxos de execução que rodam dentro de um processo (aplicação). Normalmente os threads compartilham regiões de memória, mas não necessariamente. Lembre-se de encapsulamento. Processos permitem que o seu sistema operacional execute mais de uma aplicação ao mesmo tempo, enquanto que threads permitem que sua aplicação execute mais de um método ao mesmo tempo.

A maioria dos programas simples que fazemos durante o curso só têm um único fluxo de execução. Estes programas não executam duas coisas (dois pedaços de código) simultaneamente. Grande parte do software de qualidade escrito hoje faz uso de mais de uma linha de execução, mais de um thread. São os chamados programas multithreaded.

O seu browser de hipertexto consegue fazer o download de vários arquivos ao mesmo tempo, gerenciando as diferentes velocidades de cada servidor e ainda assim permite que você continue interagindo, mudando de página no hipertexto enquanto o arquivo nem foi carregado totalmente? Isto não seria possível sem o uso de threads.
O seu editor de textos permite que você vá editando o começo do arquivo, enquanto ele está sendo carregado do disco? Editar e carregar do disco são atividades que não podem ser intercaladas de maneira simples em um pedaço de código. Seu editor está usando threads, essas atividades estão sendo feitas em paralelo.

Se sua máquina só possui um processador, esse paralelismo é um falso paralelismo. O processador tem seu tempo dividido em pequenos intervalos, em cada intervalo ele executa uma das atividades e você tem a sensação de que tudo está funcionando ao mesmo tempo, simultaneamente. Se você é um felizardo e sua máquina tem mais de um processador, então seu ambiente será capaz de mapear seus threads em hardware e você terá realmente processamento paralelo.

Se você olhar a tradução de threads no dicionário é até capaz que você encontre um desenho de um carretel de linha ou da rosca de um parafuso, este nome é bastante feliz. Imagine que seu programa é composto por várias linhas de execução que funcionam em paralelo (algumas vezes estas linhas podem se juntar, outras se dividir). Cada linha de execução cuida de uma tarefa: transferir um arquivo, tratar a entrada do usuário, mostrar sua janela na tela, etc.

Threads é uma invenção recente se comparada com o restante da linguagem. Algumas outras linguagens (bem poucas) fornecem facilidades para lidar com threads, exemplo: Modula-3. Também conhecidos como lightweight processes, threads são um recurso extremamente difícil de se implementar, de modo que é possível dizer que ou seu ambiente de programação oferece facilidades para lidar com eles, ou você não vai querer implementá-los/usá-los.

CRIANDO THREADS USANDO INTERFACES OU HERANÇA

Existem duas maneiras básicas de criar threads em Java, usando interfaces e usando herança. Usando herança (extendendo a classe Thread), sua classe já é um thread, que quando tiver seu método start() chamado vai executar tudo o que estiver no método run() em paralelo.
Usando interfaces, você define uma classe que implementa a interface Runnable, e cujo método run() vai ser executado por um thread.

HERANÇA USADA PARA CRIAR THREADS

Nós faremos uma corrida de Threads: A e B. Eles serão iniciados depois que o programa principal (main) começar. A sai com alguma vantagem pois é iniciado primeiro, depois sai B. A cada loop estes Threads são obrigados a fazer uma pausa por intervalo aleatório até completarem 4 loops: 0,1,2,3,4. No final, pedimos ao programa principal que espere os Threads terminarem seus ciclos para se juntar a eles (método join() da classe thread).O método join não retorna enquanto o seu thread não terminar.

CODIGO

public class MeuThread extends Thread {
      public MeuThread(String nome) {
            super(nome);
}
public void run(){ // o metodo que vai ser executado no thread tem sempre nome run
            for (int i=0; i<5; i++) {
                  System.out.println(getName()+ " na etapa:"+i);
            try {
            sleep((int)(Math.random() * 2000)); //milisegundos
            } catch (InterruptedException e) {}
}
            System.out.println("Corrida de threads terminada:" + getName());
}
}


class CorridaThreads {
     public static void main (String args[]){
            MeuThread a,b;
            a=new MeuThread("Aluno 1");
            a.start();
            b=new MeuThread("Aluno 2");
            b.start();
            try {a.join(); } catch (InterruptedException ignorada) {}
            try {b.join(); } catch (InterruptedException ignorada) {}
      }
}

Saída do programa

Aluno 1 na etapa:0
Aluno 2 na etapa:0
Aluno 2 na etapa:1
Aluno 1 na etapa:1
Aluno 2 na etapa:2
Aluno 1 na etapa:2
Aluno 1 na etapa:3
Aluno 2 na etapa:3
Aluno 2 na etapa:4
Corrida de threads terminada:Aluno 2
Aluno 1 na etapa:4
Corrida de threads terminada: Aluno 1