Exemplo de Thread em Java

Bem-vindo ao Exemplo de Thread em Java. Processo e Thread são duas unidades básicas de execução. A programação de concorrência está mais preocupada com as threads em Java.

Processo

A process is a self contained execution environment and it can be seen as a program or application. However a program itself contains multiple processes inside it. Java runtime environment runs as a single process which contains different classes and programs as processes.

Thread

Thread pode ser chamado de processo leve. Thread requer menos recursos para ser criada e existe no processo, a thread compartilha os recursos do processo.

Exemplo de Thread em Java

Cada aplicação Java tem pelo menos uma thread – thread principal. Embora existam muitas outras threads Java em execução em segundo plano, como gerenciamento de memória, gerenciamento do sistema, processamento de sinais etc. Mas do ponto de vista da aplicação, a principal é a primeira thread Java e podemos criar várias threads a partir dela. Multithreading refere-se a duas ou mais threads executando simultaneamente em um único programa. Um processador de núcleo único de computador pode executar apenas uma thread de cada vez e fatiamento de tempo é o recurso do sistema operacional para compartilhar o tempo do processador entre diferentes processos e threads.

Benefícios das threads Java

1. As threads Java são mais leves em comparação com os processos, levam menos tempo e recursos para criar uma thread.
2. As threads compartilham os dados e o código do processo pai
3. A troca de contexto entre as threads geralmente é menos cara do que entre os processos.
4. A comunicação entre threads é relativamente mais fácil do que a comunicação entre processos.

O Java fornece duas maneiras de criar uma thread programaticamente.

1. Implementando a interface java.lang.Runnable.
2. Estendendo a classe java.lang.Thread.

Exemplo de Thread em Java – implementando a interface Runnable

Para tornar uma classe executável, podemos implementar a interface java.lang.Runnable e fornecer uma implementação no método public void run(). Para usar esta classe como uma Thread, precisamos criar um objeto Thread passando o objeto desta classe executável e, em seguida, chamar o método start() para executar o método run() em uma thread separada. Aqui está um exemplo de thread em Java implementando a interface Runnable.

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Obter conexão com o banco de dados, excluir dados não utilizados do BD
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }

}

Exemplo de Thread em Java – estendendo a classe Thread

Pode-se estender a classe java.lang.Thread para criar nossa própria classe de thread em Java e substituir o método run(). Então, podemos criar um objeto dessa classe e chamar o método start() para executar o método run de nossa classe de thread personalizada. Aqui está um exemplo simples de thread em Java mostrando como estender a classe Thread.

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("MyThread - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Obter conexão com o banco de dados, excluir dados não utilizados do BD
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("MyThread - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
    
}

Aqui está um programa de teste mostrando como criar uma thread em Java e executá-la.

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args){
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started");
        
    }
}

A saída do programa de exemplo de thread em Java acima é:

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

Quando iniciamos qualquer thread, a execução depende da implementação do sistema operacional quanto à divisão de tempo, e não podemos controlar essa execução. No entanto, podemos definir a prioridade das threads, mas mesmo assim não garante que a thread de maior prioridade será executada primeiro. Execute o programa acima várias vezes e verá que não há um padrão para o início e término das threads.

Runnable vs Thread

Se a sua classe oferece mais funcionalidades além de simplesmente ser executada como uma thread, você deve implementar a interface Runnable para fornecer uma maneira de executá-la como uma thread. Se o único objetivo da sua classe for ser executada como uma thread, você pode estender a classe Thread. A implementação de Runnable é preferida porque o Java suporta a implementação de várias interfaces. Se você estender a classe Thread, não poderá estender outras classes. Dica: Como você observou, a thread não retorna nenhum valor, mas e se quisermos que nossa thread faça algum processamento e depois retorne o resultado ao nosso programa cliente, confira nosso Java Callable Future. Atualização: A partir do Java 8, Runnable é uma interface funcional e podemos usar expressões lambda para fornecer sua implementação, em vez de usar uma classe anônima. Para mais detalhes, consulte Java 8 Functional Interfaces.