Aula 10A

Prévia do material em texto

Aula 10 Thread 
Threads 
Classe Thread 
 
Um sistema operacional multitarefa é capaz de controlar a execução de mais de um processo ao 
mesmo tempo, de forma concorrente, fazendo a CPU alternar a execução das instruções de cada 
processo. 
 
Uma thread é um fluxo sequencial de controle, ou linha de execução, dentro de um processo ou 
programa. Um processo pode assim ter diversas threads executando concorrentemente, mas todas 
partilhando o mesmo espaço de endereçamento. Como não há necessidade de trocar de contexto, 
as threads representam uma forma mais leve de processamento concorrente. 
 
A Máquina Virtual Java (JVM) permite que uma aplicação tenha diversas linhas de execução 
rodando concorrentemente. Há sempre pelo menos uma thread, que roda o método main(). 
 
Essa thread é criada automaticamente, e outras podem ser criadas pelo programador. O programa 
gc (garbage collector) roda em outra thread também iniciada pela JVM. 
 
 
Porque usar threads em aplicações: 
 
Threads têm várias utilidades, especialmente quando o uso de um recurso do programa pode 
demandar muito tempo, e travar outras tarefas que estão aguardando, ou quando se precisa ficar 
verificando a ocorrência de algum evento para efetuar alguma ação. Nesse último caso, uma 
thread pode ficar dedicada apenas para verificar periodicamente a ocorrência do evento. 
 
A aplicação mais usual é a interação com as interfaces gráficas (menus, botões) quando se quer 
obter resposta quase que imediata a uma ação. 
 
A classe java.lang.Thread 
 
Em Java, cada thread é implementada como um objeto, que deve ser uma instância de uma 
subclasse de java.lang.Thread criada para esse fim. 
 
A interface java.lang.Runnable 
 
Essa interface obriga a ter o método public void run(). Toda thread é criada para executar os 
comandos de algum método com essa assinatura. A própria classe Thread possui esse método, 
mas vazio, ou seja, não faz nada. 
 
Em Java, existem basicamente duas maneiras de se trabalhar com Threads: Utilizando a Classe 
Thread ou a Interface Runnable. 
 
 
 
 
 
Exemplo Básico 
package programas; 
 
public class Exemplo2Thread extends Thread{ 
 
 @Override 
 public void run(){ 
 System.err.println("Esta Thread sera executada"); 
 } 
 
 public static void main(String[] args) { 
 Exemplo2Thread tr = new Exemplo2Thread(); 
 Thread trd = new Thread(tr); 
 trd.start(); 
 } 
} 
 
Exemplo1 utilizando a Classe Thread 
package Exemplos; 
 
public class Exemplo1Thread extends Thread{ 
 public Exemplo1Thread(String nome) { 
 super(nome); 
 } 
 @Override 
 public void run() { 
 for(int i = 0; i < 10; i++){ 
 System.out.println(i + " -> " + super.getName()); 
 } 
 System.out.println("Processo Finalizado!"); 
 } 
 public static void main(String[] args) { 
 Exemplo1Thread processo1 = new Exemplo1Thread("Executando Processo1"); 
 Exemplo1Thread processo2 = new Exemplo1Thread("Executando Processo2"); 
 processo1.start(); 
 processo2.start(); 
 } 
} 
 
Exemplo2 utilizando a Classe Thread e manipulando a prioridade 
package Exemplos; 
 
public class Exemplo3Thread extends Thread{ 
 Exemplo3Thread(String nome) { 
 super(nome); 
 } 
 
 @Override 
 public void run() { 
 for(int i = 0; i < 10; i++){ 
 System.out.println(i + " -> " + super.getName()); 
 } 
 System.out.println("Processo Finalizado!"); 
 } 
 public static void main(String[] args) { 
 Exemplo3Thread processo1 = new Exemplo3Thread("Executando Processo1"); 
 Exemplo3Thread processo2 = new Exemplo3Thread("Executando Processo2"); 
 processo1.setPriority(5); 
 processo2.setPriority(7); 
 processo1.start(); 
 processo2.start(); 
 } 
} 
 
Exemplo4 utilizando a Classe Thread, manipulando a prioridade e utilizando o sleep. 
package Exemplos; 
 
public class Exemplo4Thread extends Thread{ 
 
 public Exemplo4Thread(String nome) { 
 super(nome); 
 } 
 @Override 
 public void run() { 
 for(int i = 0; i < 1000; i++){ 
 System.out.println(i + " -> " + super.getName()); 
 try{ 
 //Interromper uma Thread temporariamente 
 super.sleep((long) (Math.random() * 500)); 
 } 
 catch(InterruptedException e){ 
 System.out.println(e.getMessage()); 
 } 
 } 
 System.out.println("Processo Finalizado!"); 
 } 
 public static void main(String[] args) { 
 
 Exemplo4Thread processo1 = new Exemplo4Thread("Executando Processo1"); 
 Exemplo4Thread processo2 = new Exemplo4Thread("Executando Processo2"); 
 
 processo1.setPriority(5); 
 processo2.setPriority(7); 
 
 processo1.start(); 
 processo2.start(); 
 } 
} 
Interface Runnable 
Exemplo1: 
package programas; 
 
public class PrincipalMain { 
 
 public static void main(String[] args) { 
 
 Exemplo2Runnable p1 = new Exemplo2Runnable("Processo A", 7); 
 Exemplo2Runnable p2 = new Exemplo2Runnable("Processo B", 3); 
 
 new Thread(p1).start(); 
 new Thread(p2).start(); 
 } 
} 
 
 
 
package programas; 
 
public class Exemplo2Runnable implements Runnable{ 
 private String nome; 
 private int prioridade; 
 
 Exemplo2Runnable(String nome, int prioridade) { 
 this.nome = nome; 
 this.prioridade = prioridade; 
 } 
 @Override 
 public void run() { 
 //Definindo as propriedades da Thread 
 Thread.currentThread().setPriority(prioridade); 
 Thread.currentThread().setName(nome); 
 
 for(int i = 0; i < 20; i++){ 
 System.out.println( i + " -> " + Thread.currentThread().getName()); 
 
 try{ 
 Thread.sleep((long)(Math.random() * 500)); 
 } 
 catch(InterruptedException e){ 
 System.out.println(e.getMessage()); 
 } 
 } 
 System.out.println("Fim do Processamento -> " + Thread.currentThread().getName()); 
 } 
} 
Exercícios com Thread 
1 – Escrever um programa em Java para implementar o conceito de Thread usando a interface 
Runnable. A classe principal chamará a classe executora e ela deverá imprimir uma mensagem. 
 
package programas; 
 
public class Exercicio1RunnebleMain { 
 public static void main(String[] args) { 
 Exercicio1Runneble exe = new Exercicio1Runneble(); 
 Thread t = new Thread(exe); 
 t.start(); 
 } 
} 
 
package programas; 
 
public class Exercicio1Runneble implements Runnable { 
 
 @Override 
 public void run() { 
 System.out.println("Primeiro exercício usando interface Runnable!"); 
 } 
} 
 
2 – Escrever um programa em Java para implementar o conceito de Thread usando a interface 
Runnable. A classe principal chamará a classe executora e ela deverá carregar e imprimir um 
vetor com 10 ocorrências. 
 
3 – Escrever um programa em Java para implementar o conceito de Thread usando a interface 
Runnable. A classe principal chamará a classe executora e ela deverá carregar dois vetores de 10 
ocorrências, criar um terceiro vetor que receberá a soma dos elementos carregados nos dois 
vetores e imprimir esse terceiro vetor. 
try-catch-finally 
 
Tratamento de Exceções e Erros 
 
Umas das utilidades proporcionadas pela orientação a objetos de Java é a facilidade em tratar 
possíveis erros de execução chamados de exceções. 
 
Sempre que um método de alguma classe é passível de causar algum erro, então, podemosusar o 
método de tentativa - o try. 
 
Tudo que estiver dentro do bloco try será executado até que alguma exceção seja lançada, ou 
seja, até que algo dê errado. 
 
Quando uma exceção é lançada, ela sempre deve ser capturada. O trabalho de captura da exceção 
é executado pelo bloco catch. 
 
Um bloco try pode possuir vários blocos de catch, dependendo do número de exceções que 
podem ser lançadas por uma classe ou método. 
 
O bloco catch obtém o erro criando uma instância da exceção. Portanto, a sintaxe do bloco try 
catch é: 
 
Finally 
 
Finally é o trecho de código final. A função básica de finally é sempre executar seu bloco de 
dados mesmo que uma exceção seja lançada. 
 
É muito útil para liberar recursos do sistema quando utilizamos, por exemplo, conexões de banco 
de dados e abertura de buffer para leitura ou escrita de arquivos. 
 
Finally virá após os blocos de catch. 
 
Exemplo: 
package programas; 
 
public class ExemploTryCatch { 
 public static void main(String[] args) { 
 String var = "ABC"; 
 try { 
 Integer i = new Integer(var); 
 System.out.println("A variável i vale " + i); 
 } 
 catch (NumberFormatException e) { 
 System.out.println("Não é possível atribuir a string " + var + 
 " a um Objeto Inteiro.\n" + 
 "A seguinte mensagem foi retornada:\n\n" + 
 e.getMessage()); 
 } 
 finally { 
 System.out.println("Execute mesmo com erro!"); 
 } 
 } 
}