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 chamada de processo leve. A thread requer menos recursos para ser criada e existe no processo; ela 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 de sistema, processamento de sinais, etc., 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 à execução simultânea de duas ou mais threads em um único programa. Um processador de núcleo único de computador pode executar apenas uma thread de cada vez, e divisão de tempo é a característica do sistema operacional para compartilhar o tempo do processador entre diferentes processos e threads.

Benefícios das Threads em Java

1. As threads em Java são leves em comparação com os processos; levam menos tempo e recursos para criar uma thread.
2. As threads compartilham dados e código de seu processo pai
3. A troca de contexto entre threads geralmente é menos custosa do que entre processos
4. A intercomunicaçã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 implementação no método public void run(). Para usar essa classe como Thread, precisamos criar um objeto Thread passando o objeto dessa classe executável e então chamar o método start() para executar o método run() em uma thread separada. Aqui está um exemplo de thread em Java ao implementar 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 banco de dados
            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

Podemos 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 seu objeto e chamar o método start() para executar o método run da nossa classe de thread personalizada em Java. 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 banco de dados
            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

Uma vez que começamos qualquer thread, a execução depende da implementação do sistema operacional do fatiamento de tempo e não podemos controlar sua 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 no início e no fim das threads.

Runnable vs Thread

Se 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 Thread. Se o único objetivo de sua classe é ser executada como Thread, você pode estender a classe Thread. Implementar Runnable é preferível porque o Java suporta a implementação de várias interfaces. Se você estender a classe Thread, não poderá estender nenhuma outra classe. Dica: Como você notou, a thread não retorna nenhum valor. Mas e se quisermos que nossa thread faça algum processamento e depois retorne o resultado para o 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, confira Java 8 Functional Interfaces.