Programação Orientada a Objetos (DPADF 0063)

Transcrição

1 Programação Orientada a Objetos (DPADF 0063) Aula 10 Threads Universidade Federal de Santa Maria Colégio Agrícola de Frederico Westphalen Curso Superior de Tecnologia em Sistemas para Internet Prof. Bruno B. Boniati

2 Linhas de execução independentes

3 Programação Concorrente Programar de forma concorrente significa pensar e escrever programas de computador que fazem mais de uma coisa ao mesmo tempo; Na vida real, muito do que fazemos (respirar, falar, ler, escutar) e do que os computadores fazem (compilar, imprimir, tocar música, baixar vídeo) acontece de forma concorrente. Os objetivos da programação concorrente podem ser: Reduzir o tempo total de processamento Aumentar a confiabilidade disponibilidade das aplicações Especializar serviços (SOs, simuladores), etc.

4 Onde utilizar programação concorrente? Programação Reativa A aplicação responde a eventos de entrada (em uma GUI cada evento corresponde a uma ação). Programação Interativa Escrever um programa dividindo tarefas: uma tarefa para fazer alguma interação com o usuário, outra para exibir mensagens, outra para fazer animação, etc... Paralelismo físico/distribuição Permite tirar vantagem de múltiplas CPUs centralizadas ou distribuídas (cada vez mais presentes nos sistemas computacionais).

5 Threads Uma thread é uma linha de execução, um fluxo de execução, um segmento de programa executando dentro da CPU; Programação multithreading consiste em pensar e escrever as aplicações de forma que ações sejam executadas em paralelo de forma concorrente; Apenas computadores com múltiplos processadores podem de fato executar instruções em paralelo, porém, sistemas operacionais modernos oferecem recursos para criar uma ilusão de paralelismo em máquinas monoprocessadas compartilhando o tempo de execução entre diferentes aplicações.

6 Threads (cont.) A figura abaixo demonstra a utilização da CPU por segmentos de código. Observe que apenas um segmento ocupa a CPU de cada vez e há uma fila de segmentos aguardando sua vez... CPU Segmento segmento ganha a CPU Segmento Segmento Segmento Fila de Segmentos Segmento Segmento Segmento Segmento segmento deixa a CPU

7 Programação concorrente & Java Java disponibiliza a concorrência de forma nativa por meio da linguagem e de seu framework; Ao especificar uma thread estamos criando um fluxo de execução independente, com sua própria pilha de chamadas de método e contador de programa; Java inclui primitivos de multithreading de forma integrada à linguagem de programação, não sendo necessário chamar primitivas específicas do sistema operacional (isso é muito importante para a portabilidade do código). A classe Thread representa um fluxo de execução independente para a linguagem Java.

8 Um pequeno exemplo... Compile o código abaixo e o execute a classe resultante... public class Corrida extends Thread { public Corrida(String n) { super(n); public void run() { for (int i=1; i<=10; i++) { System.out.println(getName() + " na volta " + i); O método run() contém a tarefa que a thread deve executar. Quando ele termina a thread termina System.out.println("-->" + getname() + " chegou "); public static void main (String args[]) { Corrida s = new Corrida("Sebastian Vettel"); Corrida f = new Corrida("Fernando Alonso"); Corrida k = new Corrida("Kimi Raikkonen"); s.start(); f.start(); k.start(); O método start() coloca a thread na fila para tentar ganhar CPU Quem ganhou a corrida? (execute novamente... e agora, quem ganhou?)

9 Métodos de uma thread getname() Cada thread pode opcionalmente ser identificada por um nome. setpriority(int prioridade) As threads podem ter prioridades distintas entre si (baixa, média e alta) sleep(long tempo) Faz com que a thread descanse por alguns milissegundos deixando de ocupar a CPU. Ao acordar ela volta para a fila. start() Coloca a thread na fila para tentar ganhar CPU. yield() Retira a thread da CPU e já a recoloca na fila novamente (isso dá chance de uma outra thread ganhar a CPU).

10 Ciclo de vida de uma thread running (executando) sleeping (dormindo) Monitor Waiting Dead (Encerrada) runnable (aguardando na fila da CPU) waiting (aguardando algum recurso)

11 O que leva a thread deixar a CPU? O objetivo de uma thread é alcançar a CPU para que possa ser executada, mas há situações onde a thread deixa a CPU: Voluntariamente (através do método yield() para dar chance a outras threads ocuparem o processador); Quando ela está aguardando algum recurso de IO (dados de arquivo, entrada via teclado); Quando ela está aguardando lock de um recurso compartilhado; Por preempção (alguns SOs dão uma fatia de tempo para cada thread); Por prioridade (quando alguma thread de maior prioridade aparece na fila); Ao terminar sua tarefa (quando o método run() conclui).

12 Prioridade de uma thread O modelo de escalonamento de Threads da JVM (a forma como uma Thread é elegida para utilizar a CPU) é baseada em prioridades. Existem 3 prioridades que podem ser utilizadas: Thread.MIN_PRIORITY (prioridade baixa) Thread.MAX_PRIORITY (prioridade alta) Thread.NORM_PRIORITY (prioridade normal) O método setpriority() é utilizado para indicar qual é a prioridade da Thread.

13 Prioridade de uma thread (cont.) A JVM elege as Threads de maior prioridade para ocupar a CPU em detrimento das Threads de menor prioridade. Uma Thread de menor prioridade pode será executada quando as Threads de maior prioridade terminarem executarem yield() executarem sleep() ficarem aguardando algum recurso bloqueado Se uma Thread de prioridade alta ocupar a CPU por muito tempo a JVM pode selecionar, ocasionalmente, uma Thread de prioridade mais baixa, preemptando a Thread de mais alta prioridade

14 Interface Runnable Criar uma classe descendente de Thread nem sempre é uma boa ideia, principalmente em Java, onde cada classe tem uma única superclasse. A classe Thread disponibiliza alguns métodos estáticos que recebem objetos de classes que implementam uma interface específica... Runnable A interface Runnable exige basicamente a implementação do método run().

15 Interface Runnable (cont) class Tarefa implements Runnable { String nome; public Tarefa (String n) { nome = n; A interface Runnable exige o método run() public void run() { for (int i=0; i<10; i++) System.out.println(nome + " executando tarefa (" + i + ")"); System.out.println(nome + " concluído "); public static void main(string args[]) { Tarefa t1 = new Tarefa("t1"); Tarefa t2 = new Tarefa("t2"); new Thread(t1).start(); new Thread(t2).start(); Uma nova Thread é instanciada passando como parâmetro um objeto de uma classe Runnable

16 Sincronização (Imagine o seguinte cenário) Uma classe conta bancária com métodos para obter e atualizar o saldo; public class Conta { public double saldo = 0; public Conta(double saldo) { this.saldo = saldo; System.out.println("Saldo inicial: R$" + saldo); public double getsaldo() {return saldo; public void setsaldo(double saldo) {this.saldo = saldo;

17 Sincronização (cont.) (Imagine o seguinte cenário) Um classe banco com dispositivos para movimentar as contas; public class Banco { public boolean saque(conta conta, double valor) { double saldo = conta.getsaldo(); if (saldo < valor) { System.out.println("Saldo insuficiente para o saque."); return false; double novosaldo = saldo - valor; System.out.println(Thread.currentThread().getName() + " sacou R$" + valor + ". Saldo após saque: R$" + novosaldo); conta.setsaldo(novosaldo); return true;

18 Sincronização (cont.) (Imagine o seguinte cenário) Uma classe cliente de um banco com sua conta corrente, um valor para saque e a vontade de gastar todo o dinheiro; public class Cliente extends Thread { private static Banco banco = new Banco(); private Conta conta = null; private double valor = 1000; public Cliente(String nome, Conta conta) { super(nome); this.conta = conta; public void run() { double total = 0; while (banco.saque(conta,valor)) total += valor; System.out.println(getName() + " sacou total de R$" + total);

19 Sincronização (cont.) (Imagine o seguinte cenário) Várias instâncias de clientes (uma família) movimentando uma mesma conta ao mesmo tempo. public class Familia { public static void main (String args[]) { final Conta conta = new Conta(100000); Cliente pai = new Cliente("Pai ", conta); Cliente mae = new Cliente("Mãe ", conta); Cliente filho = new Cliente("Filho", conta); pai.start(); mae.start(); filho.start();

20 Sincronização (cont.) (Observe a execução da classe família) Saldo inicial: R$ Pai sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Filho sacou R$ Saldo após saque: R$0.0 Pai sacou R$ Saldo após saque: R$ Saldo insuficiente para o saque. Mãe sacou R$ Saldo após saque: R$ Filho sacou total de R$ Pai sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$ Mãe sacou R$ Saldo após saque: R$ Pai sacou R$ Saldo após saque: R$0.0 Saldo insuficiente para o saque. Mãe sacou R$ Saldo após saque: R$0.0 Saldo insuficiente para o saque. Pai sacou total de R$ Mãe sacou total de R$ Saldo inicial R$ ,00 Saldo insuficiente para o saque Mãe sacou R$ 1000,00 (saldo após o saque R$ 3 mil) Quanto cada um sacou até que o saldo acabasse? Filho sacou total de R$ Pai sacou total de R$ Mãe sacou total de R$ 10000

21 Sincronização (cont.) O código executado anteriormente utiliza um recurso compartilhado entre todas as Threads (objeto da classe Conta); Para garantir acesso exclusivo a um recurso compartilhado, ou seja, criar uma fila de espera para utilizar o recurso um de cada vez, faz-se necessário utilizar recursos de sincronização. A palavra reservada synchronized marca um método ou um bloco de código como sincronizado, isso garante que aquele código somente será acessado por uma Thread de cada vez. Experimente alterar a interface dos métodos abaixo incluindo a palavra synchronized: Conta.getSaldo() Conta.setSaldo(double) Banco.saque(Conta, double)

22 Exercícios para fixação

23 Corrida Maluca... Codifique uma classe veículo que implementa a interface runnable. A cada corrida, cada veículo possui uma velocidade que é sorteada quando a classe é instanciada. Simule uma corrida maluca com os personagens do desenho animado Wacky Races (produzido nos estúdios Hanna-Barbera nos anos de 68 e 70). Utilize todos os personagens (Dick Vigarista & Muttley, Irmãos Rocha, Cupê Mal-Assombrado, Professor Aéreo, Barão Vermelho, Penélope Charmosa, Carro Tanque, Quadrilha de Morte, Peter Perfeito e Rufus Lenhador)