O básico de Threads no Java

Este artigo aborda tópicos sobre Concorrência e Paralelismo, primeiro de tudo vamos entender o que é uma thread.

O que é uma thread?

Processos de um computador são os programas em execução. Sendo assim, uma thread seria como um subprograma dentro de um processo. É uma linha de execução ou caminho que o processador pode seguir para realizar tarefas. Cada processo pode ter várias threads, permitindo que multiplas tarefas sejam realizadas concorrentemente.

O que é uma thread no Java?

Geralmente, todos os programas tem pelo menos uma thread, conhecida como thread principal, que é provida pela JVM no começo da execução do programa. Neste ponto, quando a thread principal é dada, o método main() é invocado pela thread principal.

No Java existe uma classe java.lang.Thread usada para criar threads. A JVM permite que uma aplicação tenha multiplas threads rodando concorrentemente. Cada uma tem uma prioridade. Threads com prioridade alta são executadas em precedência as de baixa.

Criando uma thread no Java

Uma thread pode ser criada de duas formas:

• Extendendo a classe java.lang.Thread Neste caso, a thread é criada pela nova classe que extende a classe Thread, criand uma instância desta. O método run() incluí a funcionalidade que supon-se ser implementada pela Thread. Exemplo:

public class MyThread extends Thread {
    public void run(){
        System.out.println("thread is running...");
    }
    public static void main(String args[]){
        MyThread obj = new MyThread();
        obj.start();
    }
}

start() é usado para criar uma nova thread e torna-la executavel.

• Implementando a interface Runnable Este método é mais fácil para criar uma thread. Neste caso, a classe é criada para implementar a interface Runnable e depois o método run(). O código para exeutar a thread deve sempre ser escrito dentro do método run().

public class MyThread implements Runnable {
    public void run(){
        System.out.println("thread is running...");
    }
    public static void main(String args[]){
        Thread t = new Thread(new MyThread());
        t.start();
    }
}

O método start() chama o método run(). Quando o método start() é chamado, uma nova pilha é dada para a thread, e o método run() é invocado para a nova thread no programa.

O ciclo de vida da thread

O ciclo de vida da thread em Java refere-se as transformações do estado de uma thread que começa com seu nascimento e termina com sua morte. Quando uma instância de thread é gerada e executada pela chamada do método start() da classe Thread, a thread entra no estado runnable. Quando sleep() ou wait() são chamadas a thread entra no modo non-runnable.

Há basicamente 4 estados:

1. New
2. Runnable
3. Running
4. Blocked (Non-Runnable)
5. Dead

New
Como usamos a classe Thread para contruir uma entidade thread, a thread nasce e é definida como estando no estado New. Mas, aqui o método start() ainda não foi invocado.

Runnable
Uma thread no estado runnable está preperada para executar o código. Quando o start() da nova thread é chamado, esta entra no estado runnable.

No ambiente runnable, a thread está pronta para executada e está esperando a execução na fila.

Running
O estado running implica que o processador atribui um intervalo de tempo à thread para execução.

Blocked
Quando a thread está viva, mas não pode ser selecionada pelo programador. Está inativa.

Dead
Quando a função run() da thread acaba a execução, ela morre automaticamente ou entra no estado dead. Quando a função stop() é invocada, a thread também morre.

Prioridades das threads

O número de serviços atribuídos a uma thread é designado pela prioridade. A qualquer thread gerada na JVM é dada uma prioridade. A prioridade escala de 1 a 10.

• 1 é conhecido como prioridade mais baixa.
• 5 é conhecido como prioridade padrão.
• 10 representa a prioridade mais alta.

A prioridade da thread principal é 5 por padrão, e cada thread filha vai ter a mesma prioridade da thread pai. Nós podemos ajustar a prioridade de qualquer thread, é recomendado usar as constantes da classe Thread:
Thread.MIN_PRIORITY;
Thread.NORM_PRIORITY;
Thread.MAX_PRIORITY;

public class ThreadPriority extends Thread {
    public void run(){
        System.out.println("thread is running..." + 
        Thread.currenThread().getPriority());
    }
    public static void main(String args[]){
        ThreadPriority m1 = new ThreadPriority();
        ThreadPriority m2 = new ThreadPriority();
        m1.setPriority(Thread.MIN_PRIORITY);
        m2.setPriority(Thread.MAX_PRIORITY);
        m1.start();
        m2.start();
    }
}

Referência

An introdution to the thread in Java****