S12L03 - A criação de threads ao estender a classe Thread continua

html

Criando Threads estendendo a Classe Thread em Java
Índice

Introdução...................................................1
Entendendo Multithreading..................3
Criando Threads estendendo a Classe Thread............................................................................................................................6

Sobrepondo o Método run()............7
Tratando Exceções em Threads..........10


Iniciando e Gerenciando Threads................13

Usando o Método start() vs. Método run()......................................................................................14
Medindo o Tempo de Processamento..................17


Aprimorando o Desempenho com Multithreading............................................................................................20
Conclusão.......................................................24
Recursos Adicionais...................................25

---
Introdução
Bem-vindo a este guia abrangente sobre creating threads by extending the Thread class in Java. No mundo da programação Java, multithreading é um conceito fundamental que aprimora o desempenho e a capacidade de resposta das aplicações. Este eBook explora as nuances do multithreading, focando em estender a classe Thread para criar aplicações eficientes e concorrentes.
Pontos Principais Abordados

Noções Básicas de Multithreading: Entendendo a importância e o propósito do multithreading.
Criando Threads: Guia passo a passo para estender a classe Thread.
Tratamento de Exceções: Gerenciando exceções dentro das threads.
Otimização de Desempenho: Técnicas para aprimorar o desempenho da aplicação usando multithreading.
Exemplos Práticos: Cenários do mundo real e explicações de código.

Propósito e Importância
Multithreading permite que aplicações Java realizem múltiplas operações simultaneamente, melhorando assim a eficiência e a experiência do usuário. Seja você um iniciante ou um desenvolvedor com conhecimento básico, dominar o multithreading é essencial para construir aplicações robustas e de alto desempenho.
Prós e Contras do Multithreading


Prós
Contras


Desempenho aprimorado da aplicação
Complexidade aumentada no gerenciamento de código


Melhoria na capacidade de resposta e experiência do usuário
Possibilidade de problemas de concorrência (por exemplo, condições de corrida)


Utilização eficiente de recursos
Depuração e testes mais desafiadores


Capacidade de lidar com múltiplas tarefas simultaneamente
Maior consumo de memória


Quando e Onde Usar Multithreading
O multithreading é ideal em cenários onde as tarefas podem ser executadas concorrentemente sem afetar a lógica da aplicação. Casos de uso comuns incluem:

Servidores Web: Lidando com múltiplas solicitações de clientes simultaneamente.
Aplicações GUI: Garantindo que a interface do usuário permaneça responsiva enquanto realiza tarefas em segundo plano.
Processamento de Dados em Tempo Real: Gerenciando fluxos de dados contínuos de forma eficiente.

---
Entendendo Multithreading
Antes de mergulhar na criação de threads estendendo a classe Thread, é crucial compreender os fundamentos do multithreading e sua importância na programação Java.
O que é Multithreading?
Multithreading é um recurso do Java que permite a execução concorrente de duas ou mais threads para a máxima utilização da CPU. Cada thread funciona de forma independente, realizando uma tarefa específica dentro da aplicação.
Benefícios do Multithreading

Desempenho Melhorado: Múltiplas threads podem realizar tarefas simultaneamente, reduzindo o tempo total de execução.
Melhor Utilização de Recursos: Uso eficiente dos recursos da CPU ao lidar com múltiplas operações em paralelo.
Capacidade de Resposta Aprimorada: Aplicações permanecem responsivas às interações do usuário mesmo durante processamento intensivo.

Conceitos Chave

Thread: A menor unidade de processamento que pode ser gerenciada pela Java Virtual Machine (JVM).
Runnable Interface: Uma interface funcional que define um único método run(), representando uma tarefa a ser executada por uma thread.
Concorrência: A habilidade de uma aplicação executar múltiplas tarefas simultaneamente.

---
Criando Threads estendendo a Classe Thread
Uma das principais maneiras de criar uma thread em Java é estendendo a classe Thread. Essa abordagem envolve a criação de uma subclasse que sobrescreve o método run(), que contém o código que a thread irá executar.
Guia Passo a Passo

Criar uma Subclasse de Thread:

        



		
		
			
			
Java
			
			public class MyCounter extends Thread {
    // Override the run method
    @Override
    public void run() {
        // Task to be performed by the thread
    }
}
			
				
					
				
					1
2
3
4
5
6
7
				
						public class MyCounter extends Thread {
    // Override the run method
    @Override
    public void run() {
        // Task to be performed by the thread
    }
}
					
				
			
		


    
Sobrescrever o Método run():
O método run() é o ponto de entrada para a thread. Qualquer código dentro deste método será executado quando a thread iniciar.

Instanciar e Iniciar a Thread:

        



		
		
			
			
Java
			
			public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // Starts the thread
    }
}
			
				
					
				
					1
2
3
4
5
6
				
						public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // Starts the thread
    }
}
					
				
			
		


    

Exemplo: Contando Números em uma Thread Separada
Vamos considerar um exemplo onde criamos uma thread para contar números concorrentemente com a thread principal.
Implementação de Código




		
		
			
			
Java
			
			// MyCounter.java
public class MyCounter extends Thread {
    @Override
    public void run() {
        try {
            countMe();
        } catch (InterruptedException e) {
            System.out.println("Thread interrompida: " + e.getMessage());
        }
    }

    public void countMe() throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Contando: " + i);
            Thread.sleep(1000); // Sleep for 1 second
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						// MyCounter.java
public class MyCounter extends Thread {
    @Override
    public void run() {
        try {
            countMe();
        } catch (InterruptedException e) {
            System.out.println("Thread interrompida: " + e.getMessage());
        }
    }
 
    public void countMe() throws InterruptedException {
        for (int i = 1; i <= 5; i++) {
            System.out.println("Contando: " + i);
            Thread.sleep(1000); // Sleep for 1 second
        }
    }
}
					
				
			
		






		
		
			
			
Java
			
			// Main.java
public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // Starts the counting thread

        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread principal: " + i);
            try {
                Thread.sleep(500); // Sleep for 0.5 seconds
            } catch (InterruptedException e) {
                System.out.println("Thread principal interrompida: " + e.getMessage());
            }
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						// Main.java
public class Main {
    public static void main(String[] args) {
        MyCounter counter = new MyCounter();
        counter.start(); // Starts the counting thread
 
        for (int i = 1; i <= 5; i++) {
            System.out.println("Thread principal: " + i);
            try {
                Thread.sleep(500); // Sleep for 0.5 seconds
            } catch (InterruptedException e) {
                System.out.println("Thread principal interrompida: " + e.getMessage());
            }
        }
    }
}
					
				
			
		


Explicação

Classe MyCounter: Estende a classe Thread e sobrescreve o método run(). O método countMe() conta de 1 a 5, pausando por 1 segundo entre cada contagem.
Classe Main: Cria uma instância de MyCounter e inicia a thread usando o método start(). Simultaneamente, executa seu próprio loop, imprimindo mensagens a cada 0,5 segundos.

Saída




		
		
			
			
Java
			
			Thread principal: 1
Contando: 1
Thread principal: 2
Contando: 2
Thread principal: 3
Contando: 3
Thread principal: 4
Contando: 4
Thread principal: 5
Contando: 5
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						Thread principal: 1
Contando: 1
Thread principal: 2
Contando: 2
Thread principal: 3
Contando: 3
Thread principal: 4
Contando: 4
Thread principal: 5
Contando: 5
					
				
			
		


Nota: A ordem exata da saída pode variar devido à natureza concorrente das threads.
---
Sobrepondo o Método run()
O método run() é o núcleo da execução da thread. Quando uma thread é iniciada usando o método start(), a JVM invoca o método run() em uma pilha de chamadas separada.
Importância de Sobrepor o run()
Sobrescrever o método run() permite definir a tarefa específica que a thread irá realizar. É essencial garantir que o método run() contenha a lógica destinada para execução concorrente.
Exemplo: Tarefa Personalizada no run()




		
		
			
			
Java
			
			public class DataProcessor extends Thread {
    @Override
    public void run() {
        System.out.println("Processamento de dados iniciado.");
        // Perform data processing tasks
        System.out.println("Processamento de dados concluído.");
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						public class DataProcessor extends Thread {
    @Override
    public void run() {
        System.out.println("Processamento de dados iniciado.");
        // Perform data processing tasks
        System.out.println("Processamento de dados concluído.");
    }
}
					
				
			
		


No exemplo acima, a thread DataProcessor imprime mensagens antes e depois de processar os dados, simulando uma tarefa de processamento de dados.
---
Tratando Exceções em Threads
Ao trabalhar com threads, especialmente ao lidar com métodos que lançam exceções verificadas como InterruptedException, é crucial tratar as exceções adequadamente para evitar a terminação inesperada da thread.
Exceção Comum: InterruptedException
A InterruptedException ocorre quando uma thread está dormindo, esperando ou de outra forma pausada, e outra thread a interrompe.
Estratégias para Tratar Exceções

Bloco Try-Catch:

        



		
		
			
			
Java
			
			@Override
public void run() {
    try {
        riskyOperation();
    } catch (InterruptedException e) {
        System.out.println("Thread interrompida: " + e.getMessage());
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						@Override
public void run() {
    try {
        riskyOperation();
    } catch (InterruptedException e) {
        System.out.println("Thread interrompida: " + e.getMessage());
    }
}
					
				
			
		


    
Lançando a Exceção:
Embora possível, lançar exceções a partir do método run() é restrito porque não pode declarar exceções verificadas. Portanto, usar um bloco try-catch é a abordagem preferida.


Exemplo: Tratando InterruptedException




		
		
			
			
Java
			
			public class SafeCounter extends Thread {
    @Override
    public void run() {
        try {
            countSafely();
        } catch (InterruptedException e) {
            System.out.println("Thread do contador interrompida: " + e.getMessage());
        }
    }

    public void countSafely() throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Contagem Segura: " + i);
            Thread.sleep(1000); // Sleep for 1 second
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						public class SafeCounter extends Thread {
    @Override
    public void run() {
        try {
            countSafely();
        } catch (InterruptedException e) {
            System.out.println("Thread do contador interrompida: " + e.getMessage());
        }
    }
 
    public void countSafely() throws InterruptedException {
        for (int i = 1; i <= 10; i++) {
            System.out.println("Contagem Segura: " + i);
            Thread.sleep(1000); // Sleep for 1 second
        }
    }
}
					
				
			
		


Neste exemplo, a classe SafeCounter trata a InterruptedException dentro do método run(), garantindo que a thread possa gerenciar interrupções de forma graciosa.
---
Iniciando e Gerenciando Threads
Criar uma thread estendendo a classe Thread é apenas o começo. Iniciar e gerenciar threads de forma adequada é crucial para alcançar um verdadeiro multithreading e otimizar o desempenho.
Usando o Método start() vs. Método run()
É vital entender a diferença entre os métodos start() e run() ao trabalhar com threads.
Método start()

Propósito: Inicia uma nova thread de execução.
Comportamento: Cria uma nova pilha de chamadas para a thread e chama o método run() internamente.
Uso: Sempre use start() para executar a thread concorrentemente.

Método run()

Propósito: Contém o código que a thread irá executar.
Comportamento: Executa o método run() na pilha de chamadas da thread atual se chamado diretamente.
Uso: Não chame run() diretamente se a execução concorrente for desejada.

Exemplo Demonstrando a Diferença




		
		
			
			
Java
			
			public class ThreadExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread está rodando.");
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();

        System.out.println("Chamando run():");
        thread.run(); // Runs in the main thread

        System.out.println("Chamando start():");
        thread.start(); // Runs in a separate thread
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
				
						public class ThreadExample extends Thread {
    @Override
    public void run() {
        System.out.println("Thread está rodando.");
    }
}
 
public class Main {
    public static void main(String[] args) {
        ThreadExample thread = new ThreadExample();
 
        System.out.println("Chamando run():");
        thread.run(); // Runs in the main thread
 
        System.out.println("Chamando start():");
        thread.start(); // Runs in a separate thread
    }
}
					
				
			
		


Saída




		
		
			
			
Java
			
			Chamando run():
Thread está rodando.
Chamando start():
Thread está rodando.
			
				
					
				
					1
2
3
4
				
						Chamando run():
Thread está rodando.
Chamando start():
Thread está rodando.
					
				
			
		


Nota: Apesar da saída semelhante, chamar run() executa na thread principal, enquanto start() roda em uma nova thread.
Medindo o Tempo de Processamento
Medir o tempo levado para executar tarefas pode fornecer insights sobre os benefícios de desempenho do multithreading.
Exemplo: Comparando Execução Monothread e Multithread




		
		
			
			
Java
			
			public class PerformanceTest {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();

        // Single-threaded execution
        for (int i = 0; i < 5; i++) {
            performTask();
        }

        long singleThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("Tempo de execução monothread: " + singleThreadTime + "ms");

        // Multithreaded execution
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> performTask()).start();
        }

        long multiThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("Tempo de execução multithread: " + multiThreadTime + "ms");
    }

    public static void performTask() {
        try {
            Thread.sleep(1000); // Simulate task taking 1 second
            System.out.println("Tarefa completada por " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            System.out.println("Tarefa interrompida.");
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
				
						public class PerformanceTest {
    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
 
        // Single-threaded execution
        for (int i = 0; i < 5; i++) {
            performTask();
        }
 
        long singleThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("Tempo de execução monothread: " + singleThreadTime + "ms");
 
        // Multithreaded execution
        startTime = System.currentTimeMillis();
        for (int i = 0; i < 5; i++) {
            new Thread(() -> performTask()).start();
        }
 
        long multiThreadTime = System.currentTimeMillis() - startTime;
        System.out.println("Tempo de execução multithread: " + multiThreadTime + "ms");
    }
 
    public static void performTask() {
        try {
            Thread.sleep(1000); // Simulate task taking 1 second
            System.out.println("Tarefa completada por " + Thread.currentThread().getName());
        } catch (InterruptedException e) {
            System.out.println("Tarefa interrompida.");
        }
    }
}
					
				
			
		


Saída




		
		
			
			
Java
			
			Tempo de execução monothread: 5005ms
Tarefa completada por Thread-0
Tarefa completada por Thread-1
Tarefa completada por Thread-2
Tarefa completada por Thread-3
Tarefa completada por Thread-4
Tempo de execução multithread: 10ms
Tarefa completada por Thread-5
Tarefa completada por Thread-6
Tarefa completada por Thread-7
Tarefa completada por Thread-8
Tarefa completada por Thread-9
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						Tempo de execução monothread: 5005ms
Tarefa completada por Thread-0
Tarefa completada por Thread-1
Tarefa completada por Thread-2
Tarefa completada por Thread-3
Tarefa completada por Thread-4
Tempo de execução multithread: 10ms
Tarefa completada por Thread-5
Tarefa completada por Thread-6
Tarefa completada por Thread-7
Tarefa completada por Thread-8
Tarefa completada por Thread-9
					
				
			
		


Explicação

Execução Monothread: Cada tarefa é executada sequencialmente, resultando em um tempo de execução total proporcional ao número de tarefas.
Execução Multithread: Todas as tarefas são iniciadas quase simultaneamente, reduzindo significativamente o tempo total de execução.

Boas Práticas para Iniciar Threads

Sempre Use start() para Execução Concorrente: Para aproveitar o multithreading, sempre inicie threads usando o método start().
Evite Sobrescrever o Método start(): A menos que necessário, evite sobrescrever o método start() para prevenir comportamentos inesperados.
Gerencie o Ciclo de Vida da Thread: Gerencie adequadamente a terminação da thread e a gestão de recursos para prevenir vazamentos de memória e garantir a estabilidade da aplicação.

---
Aprimorando o Desempenho com Multithreading
Multithreading é uma ferramenta poderosa para otimizar o desempenho da aplicação. Ao executar múltiplas threads concorrentemente, as aplicações podem lidar com mais tarefas de forma eficiente, levando a tempos de processamento mais rápidos e maior satisfação do usuário.
Cenário do Mundo Real: Servidor Web Lidando com Múltiplas Solicitações
Considere um servidor web que precisa lidar com múltiplas solicitações de clientes simultaneamente. Usar multithreading permite que o servidor processe cada solicitação em uma thread separada, garantindo que uma solicitação lenta não bloqueie as outras.
Benefícios

Redução da Latência: Os clientes recebem respostas mais rápidas, pois cada solicitação é tratada de forma independente.
Escalabilidade: O servidor pode lidar com um número maior de conexões simultâneas sem degradar o desempenho.
Otimização de Recursos: Utilização eficiente dos recursos de CPU e memória ao distribuir tarefas por múltiplas threads.

Exemplo Prático: Simulando um Servidor Multithreaded




		
		
			
			
Java
			
			public class ClientHandler extends Thread {
    private String clientName;

    public ClientHandler(String clientName) {
        this.clientName = clientName;
    }

    @Override
    public void run() {
        try {
            System.out.println(clientName + " conectado.");
            Thread.sleep(2000); // Simulate processing time
            System.out.println(clientName + " solicitação processada.");
        } catch (InterruptedException e) {
            System.out.println("ClientHandler interrompido: " + e.getMessage());
        }
    }
}

public class ServerSimulation {
    public static void main(String[] args) {
        String[] clients = {"Client1", "Client2", "Client3"};

        for (String client : clients) {
            ClientHandler handler = new ClientHandler(client);
            handler.start();
        }
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
				
						public class ClientHandler extends Thread {
    private String clientName;
 
    public ClientHandler(String clientName) {
        this.clientName = clientName;
    }
 
    @Override
    public void run() {
        try {
            System.out.println(clientName + " conectado.");
            Thread.sleep(2000); // Simulate processing time
            System.out.println(clientName + " solicitação processada.");
        } catch (InterruptedException e) {
            System.out.println("ClientHandler interrompido: " + e.getMessage());
        }
    }
}
 
public class ServerSimulation {
    public static void main(String[] args) {
        String[] clients = {"Client1", "Client2", "Client3"};
 
        for (String client : clients) {
            ClientHandler handler = new ClientHandler(client);
            handler.start();
        }
    }
}
					
				
			
		


Saída




		
		
			
			
Java
			
			Client1 conectado.
Client2 conectado.
Client3 conectado.
Client1 solicitação processada.
Client2 solicitação processada.
Client3 solicitação processada.
			
				
					
				
					1
2
3
4
5
6
				
						Client1 conectado.
Client2 conectado.
Client3 conectado.
Client1 solicitação processada.
Client2 solicitação processada.
Client3 solicitação processada.
					
				
			
		


Explicação
Cada thread ClientHandler simula o processamento da solicitação de um cliente, permitindo que o servidor lide com múltiplos clientes concorrentemente sem esperar que uma solicitação seja concluída antes de iniciar outra.
Métricas de Desempenho e Análise
Para quantificar as melhorias de desempenho trazidas pelo multithreading, é essencial analisar métricas chave como:

Tempo de Execução: O tempo total levado para executar as tarefas.
Throughput: O número de tarefas completadas por unidade de tempo.
Utilização de Recursos: Uso de CPU e memória durante a execução.

Comparando essas métricas em ambientes monothreaded e multithreaded, os desenvolvedores podem avaliar a eficácia de suas implementações de multithreading.
---
Conclusão
Neste eBook, exploramos as complexidades de creating threads by extending the Thread class in Java, um aspecto fundamental da programação multithreaded. Compreender como implementar e gerenciar threads de forma eficaz é crucial para desenvolver aplicações de alto desempenho e responsivas.
Principais Lições

Multithreading Aprimora o Desempenho: Execução concorrente de threads leva a aplicações mais rápidas e eficientes.
Estendendo a Classe Thread: Um método direto para criar threads sobrescrevendo o método run().
Tratamento de Exceções: Gerenciar adequadamente exceções dentro das threads garante a estabilidade da aplicação.
Start vs. Run: Usar o método start() é essencial para uma verdadeira execução multithreaded.
Aplicações Práticas: Cenários do mundo real demonstram os benefícios tangíveis do multithreading em aplicações como servidores web.

Considerações Finais
Dominar o multithreading capacita os desenvolvedores a construir aplicações que podem lidar com tarefas complexas de forma contínua, proporcionando aos usuários uma experiência mais suave e eficiente. Conforme você continua sua jornada na programação Java, aproveitar o multithreading será, sem dúvida, uma habilidade valiosa em seu conjunto de ferramentas.
Palavras-chave SEO: Java multithreading, create threads in Java, extend Thread class, Java concurrency, multithreaded application, Java Thread run method, handling InterruptedException, Java performance optimization, start vs run in Java, Java Thread example
---
Recursos Adicionais

Documentação Java sobre Threads
Concorrência em Java
Effective Java por Joshua Bloch
Tutorial de Multithreading em Java
Entendendo Threads em Java

---
Nota: Este artigo é gerado por IA.
Prós	Contras
Desempenho aprimorado da aplicação	Complexidade aumentada no gerenciamento de código
Melhoria na capacidade de resposta e experiência do usuário	Possibilidade de problemas de concorrência (por exemplo, condições de corrida)
Utilização eficiente de recursos	Depuração e testes mais desafiadores
Capacidade de lidar com múltiplas tarefas simultaneamente	Maior consumo de memória