A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Ronaldo Celso Messias Correia Programação Concorrente Threads.

Apresentações semelhantes


Apresentação em tema: "Ronaldo Celso Messias Correia Programação Concorrente Threads."— Transcrição da apresentação:

1 Ronaldo Celso Messias Correia Programação Concorrente Threads

2 Servidores Concorrentes Aguarda pedido Trata pedido Início Aguarda pedido cria uma thread tratadora e volta Responde Trata pedido Responde tratador termina Trata pedido Responde tratador termina Trata pedido Responde tratador termina... pedido resposta resp. pedido Seqüencial Concorrente resp.

3 Programação concorrente: introdução O mundo real funciona concorrentemente: várias atividades podem ser executadas em paralelo. Exemplo: uma pessoa pode estar respirando, e, falando, e escrevendo, e lendo, etc. Computadores também operam concorrentemente. Exemplo: um computador pode estar compilando um programa, e recebendo uma mensagem, e, imprimindo um arquivo, e, tocando música, etc.

4 Threads: o que são? Definição básica: Fluxo de controle seqüencial isolado dentro de um programa. Programas multithreaded: Múltiplos threads concorrentes de execução num único programa, realizando várias tarefas ao mesmo tempo. Exemplo: programa do usuário + coleta de lixo Diferentes threads podem executar em diferentes processadores, se disponíveis, ou compartilhar um processador único Diferentes threads no mesmo programa compartilham um ambiente global (memória, processador, registradores, etc.)

5 Algumas aplicações multithreaded Programação Reativa: aplicação responde a eventos de entrada. Exemplo: interfaces com o usuário, onde cada evento corresponde a uma ação Programação Interativa: 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: para tirar vantagem de múltiplas CPUs centralizadas ou distribuídas

6 Programação concorrente: níveis Sistema operacional: primitivas de controle forma de escalonamento Ambiente de execução Java depende do SO Windows: time-slice Solaris: prioridade sistema operacional ambiente aplicação processador programa tarefa2 tarefa1 Aplicação Java: biblioteca de classes java. lang Thread, ThreadGroup,ThreadLocal, ThreadDeath

7 Fluxo de execução Execução seqüencial Comandos de controle de fluxo de execução Seqüencial Condicional Iterativo Requisição de execução de unidades explícita:chamada de métodos implícita: ativação de exceções Programa controla a ordem de execução Execução concorrente Cada tarefa é uma unidade de execução autônoma (um thread) Tarefas podem ser totalmente independentes Exemplo: execução de um mesmo método sobre dois objetos (da mesma classe) Tarefas podem necessitar comunicação Programa não controla a ordem de execução

8 Criação de threads em Java Criar uma subclasse da classe Thread public class MyClass extends Thread {... } Implementar a interface Runnable; public class MyClass extends Applet implements Runnable {... } class Thread class MyClass class Applet interface Runnable class MyClass

9 Execução de threads Cada thread possui um método run() que define a atividade concorrente Exemplo: public void run( ) { for (int count=0; count<1000; count++) System.out.println(nome); } A atividade concorrente inicia quando é invocado o método start() sobre um objeto. Exemplo: public static void main(String[] arg) {.... um.start( ); dois.start( );......} O que? Quando?

10 Classe Thread Usada quando a classe a ser executada concorrentemente não deriva de outra classe Contém métodos para controlar a execução Criação e execução: Declarar uma nova classe que seja subclasse da classe Thread Sobrescrever o método run() com o código que será executado pela thread Instanciar a nova classe Invocar seu método start(); o método rodará em seu próprio thread de controle

11 Contexto da classe Thread java.lang.Object java.lang.Thread public class Thread extends Object implements Runnable Alguns métodos da classe Thread start(): inicia a execução do Thread; sleep(): suspende a execução por um determinado tempo (especificado em milisegundos) e automaticamente recomeça a execução; destroy(): destrói esta thread.

12 Exemplo de extensão Thread class Piloto extends Thread{ private String nome; public Piloto(String str){ nome = str; } public void run(){ System.out.println("****LARGADA ****"); System.out.println(Primeira volta: " + nome); for(int cont=0; cont<10000; cont++){}; System.out.println(nome + " -> Terminou a Corrida !!!"); }

13 Exemplo de execução public class CorridaT { public static void main(String[] args) { Piloto um = new Piloto("Rubinho"); Piloto dois = new Piloto("Schumacher"); Piloto tres = new Piloto("Hakkinnen"); um.start(); dois.start(); tres.start(); } CorridaT umdoistres Quem terminará antes?

14 Resultado de uma execução *** LARGADA *** Primeira volta:Rubinho Primeira volta:Schumacher Primeira volta:Hakkinnen Rubinho -> Terminou a Corrida !!! Hakkinnen -> Terminou a Corrida !!! Schumacher -> Terminou a Corrida !!! CorridaT umdoistres

15 Resultado de outra execução *** LARGADA *** Primeira volta:Rubinho Rubinho -> Terminou a Corrida !!! *** LARGADA *** Primeira volta:Schumacher *** LARGADA *** Schumacher -> Terminou a Corrida !!! Primeira volta:Hakkinnen Hakkinnen -> Terminou a Corrida !!! CorridaT umdoistres

16 Interface Runnable Usada quando não se pode herdar da classe Thread, pois há necessidade de herança de alguma outra classe possui apenas o método run() Cria-se um objeto da classe base Thread, porém o código a ser executado está descrito na classe do usuário(derivada + ancestrais). Criação e execução: Declarar uma nova classe que implementa a interface Runnable Sobrescrever o método run() Criar um objeto da classe Thread. Exemplo: Thread um = new Thread(this);

17 Exemplo de implementação Runnnable (1) class PilotoR implements Runnable{ private String nome; public PilotoR(String str){ nome = str; } public void run(){ System.out.println("*** LARGADA ***"); System.out.println(" Primeira volta:" + nome); for(int cont=0; cont<10000; cont++) {}; System.out.println(nome + " -> Terminou a Corrida !!!"); }

18 Exemplo de implementação Runnnable (2) public class CorridaR { public static void main(String[] args) { PilotoR um = new PilotoR("Rubinho"); PilotoR dois = new PilotoR("Schumacher"); PilotoR tres = new PilotoR("Hakkinnen"); new Thread(um).start(); new Thread(dois).start(); new Thread(tres).start(); }

19 Estados de Threads new blocked running dead start Sleep done sleeping wait sleep Waiting I/O I/O done destroy No decorrer da execução, threads podem alterar seu estado: ativo inativo encerrado

20 Exemplo de sleep class PrintThread extends Thread { private int sleepTime; public PrintThread (String name) { // construtor super(nome); // nome do thread: construtor de Tread sleepTime=(int)(Math.random() * 5000); // 0-5 sec System.out.println(Name: + getName() + ; sleep + sleepTime); } public void run ( ) { try{ System.out.println(getName() + going to sleep); Thread.sleep (sleepTime) ;} catch ( InterruptedException exception) { System.out.println(exception.toString()); } Exemplo de Deitel.com dorme! fui interrompida? quem?

21 Exceção: sleep try { System.out.println(getName() + going to sleep); Thread.sleep (sleepTime) ; } catch ( InterruptedException exception) { System.out.println(exception.toString()); } método sleep pode disparar exceção* nome da exceção * se outro thread chama o método interrupt durante sleep

22 Exemplo de programa de teste public class ThreadTester { public static void main(String args[]){ PrintThread t1, t2, t3; t1 = new PrintThread(pata); t2 = new PrintThread(peta); t3 = new PrintThread(pita); System.out.println(\n Iniciando...): t1.start(); t2.start(); t3.start(); System.out.println(\n Iniciadas !): } pata peta pita

23 Prioridades Cada thread possui uma prioridade (entre 1 e 10) Default: prioridade = 5 Prioridade transmitida por herança Threads de igual prioridade cedem processador por: chamada de yield time-slicing Thread de mais alta prioridade apta a executar: faz com que a thread de menor prioridade ceda o processador seja executada até que termine a sua execução, ou, tenha a sua execução suspensa (sleep/wait...)

24 Resumo de estados de threads A execução do thread depende do ambiente de execução (sistema operacional) New threads: thread criado com new mas ainda não está rodando Runnable threads: Depois de chamado o método start(), o thread está apto a ser executada (depende da disponibilidade do sistema) Blocked threads: um thread entra no estado bloqueado quando ocorre chamada aos métodos sleep(), suspend() ou wait() espera por I/O Dead threads: execução encerrada ( o objeto thread é destruído)

25 Sincronismo: exclusão mútua Modelo: monitor (Hoare) Cada objeto que possui um método synchronized é considerado um monitor Quando este método é chamado ocorre um bloqueio (lock) Todos os demais threads devem aguardar o desbloqueio thread 1thread 2 public synchronized void recurso (..){ } OBS: Uma classe pode possuir diversos métodos synchronized mas somente um pode estar ativo em um determinado momento

26 Lista de espera Objetos monitores mantém uma lista de threads que aguardam a execução de algum método synchronized Nesta lista são inseridas threads que : chamaram um método synchronized chamaram um wait ( aguardam notify) Deadlock: se algum método synchronized não for desbloqueado, o mecanismo de sincronização Java dispara uma exceção e o tratador desbloqueia o método

27 Thread (Múltiplas Linhas de Execução) Os programas de múltiplas linhas de execução ampliam a idéia da multitarefa Os programas individuais parecerão realizar várias tarefas ao mesmo tempo O programador especifica que os aplicativos contêm fluxos de execução (threads) Cada uma designa uma parte do programa que pode ser executada simultaneamente com outras threads Diferença de Múltiplos Processos e Múltiplas Linhas de Execução Enquanto cada processo tem um conjunto completo de variáveis próprias, as linhas de execução compartilham os mesmos dados

28 Threads (Múltiplas Linhas de Execução) Os programas de múltiplas linhas de execução ampliam a idéia da multitarefa Os programas individuais parecerão realizar várias tarefas ao mesmo tempo O programador especifica que os aplicativos contêm fluxos de execução (threads) Cada uma designa uma parte do programa que pode ser executada simultaneamente com outras threads Diferença de Múltiplos Processos e Múltiplas Linhas de Execução Enquanto cada processo tem um conjunto completo de variáveis próprias, as linhas de execução compartilham os mesmos dados

29 Servidor TCP com Múltiplas Threads public class TCPServer { public static void main(String[] args) { try { new TCPServer(); } catch( Exception e ) { System.out.println(e.getMessage()); } public TCPServer throws Exception { ServerSocket ss = null; Socket cliente = null; ss = new ServerSocket(5474); System.out.println("Aguardando porta " + ss.getLocalPort()); while (true) { // inicializacao da conexao cliente = ss.accept(); // Cria uma thread para cada requisição conexao = new Conexao(cliente); conexao.start(); }

30 Servidor TCP com Múltiplas Threads public class Conexao extends Thread { Socket cliente; public Conexao(Socket s) { cliente = s; } public void run() { try { os = new ObjectOutputStream(cliente.getOutputStream()); // obtem a data do sistema para enviar ao cliente String data = new java.util.Date().toString() ; // escreve data para cliente System.out.println("Server: Enviando \"" + new String(buffer) + "\""); os.writeObject(data); os.flush(); } catch( Exception e ) { System.out.println( e.getMessage() ); }

31 Aplicação Chat – Cliente/Servidor 1 // Server.java 2 // Configura um servidor que irá receber uma conexãode um cliente, enviar 3 // uma string e fechar a conexão. 4 import java.io.*; 5 import java.net.*; 6 import java.awt.*; 7 import java.awt.event.*; 8 import javax.swing.*; 9 10 public class Server extends JFrame { 11 private JTextField enterField; 12 private JTextArea displayArea; 13 private ObjectOutputStream output; 14 private ObjectInputStream input; 15 private ServerSocket server; 16 private Socket connection; 17 private int counter = 1; // configura GUI 20 public Server() 21 { 22 super( "Servidor" ); Container container = getContentPane(); 25 O listen está sobre o ServerSocket ; a conexão é um Socket

32 Aplicação Chat – Cliente/Servidor 26 // cria compo de entrada e configura o listener (evento) 27 enterField = new JTextField(); 28 enterField.setEditable( false ); 29 enterField.addActionListener( 30 new ActionListener() { // envia mensagem ao cliente 33 public void actionPerformed( ActionEvent event ) 34 { 35 sendData( event.getActionCommand() ); 36 enterField.setText( "" ); 37 } 38 } 39 ); container.add( enterField, BorderLayout.NORTH ); // cria área de display 44 displayArea = new JTextArea(); 45 container.add( new JScrollPane( displayArea ), 46 BorderLayout.CENTER ); setSize( 300, 150 ); 49 setVisible( true ); } // fim Construtor 52 Server.java

33 Aplicação Chat – Cliente/Servidor 53 // configura e executa o servidor 54 public void runServer() 55 { 56 // configura o servidor para receber conexões; processa as conexões 57 try { // Passo 1: Cria o ServerSocket. 60 server = new ServerSocket( 12345, 100 ); while ( true ) { try { 65 waitForConnection(); // Passo 2: Aguarda conexão. 66 getStreams(); // Passo 3: Obtém input & output streams. 67 processConnection(); // Passo 4: Processa conexão. 68 } // processa EOFException quando o cliente encerra a conexão 71 catch ( EOFException eofException ) { 72 System.err.println( O Cliente encerrou a conexão!" ); 73 } finally { 76 closeConnection(); // Passo 5: Fecha a conexão counter; 78 } Cria ServerSocket para a porta com fila de tamanho 100 Server.java

34 Aplicação Chat – Cliente/Servidor } // end while } // end try // processa problemas com I/O 85 catch ( IOException ioException ) { 86 ioException.printStackTrace(); 87 } } // end Método runServer // Aguarda os pedidos de conexão, e depois mostra a informação de conexão 92 private void waitForConnection() throws IOException 93 { 94 displayArea.append( Aguardando por conexões\n" ); 95 connection = server.accept(); // permite o servidor aceitar conexões 96 displayArea.append( "Conexão " + counter + " recebida de : " + 97 connection.getInetAddress().getHostName() ); 98 } // Obtém streams para enviar e receber dados 101 private void getStreams() throws IOException 102 { Server.java Linha 95 Linhas Método accept aguarda por conexão Exibe o nome do computador que conectou

35 Aplicação Chat – Cliente/Servidor 103 // configura output stream 104 output = new ObjectOutputStream( connection.getOutputStream() ); 105 output.flush(); // esvazia buffer de saída // configura input stream 108 input = new ObjectInputStream( connection.getInputStream() ); displayArea.append( "\nI/O streams obtidos!\n" ); 111 } // processa conexão com o cliente 114 private void processConnection() throws IOException 115 { 116 // envia mensagem de conexão bem-sucedida para o cliente 117 String message = "Conexão bem sucedida!"; 118 sendData( message ); // habilita campo de entrada para o usuário do servidor 121 enterField.setEditable( true ); do { // processa mensagens enviadas pelo cliente 124 Server.java Linha 105 Método flush descarrega buffer de saída para enviar cabeçalho de informação

36 Aplicação Chat – Cliente/Servidor 125 // lê as mensagens e as mostra 126 try { 127 message = ( String ) input.readObject(); 128 displayArea.append( "\n" + message ); 129 } // captura problemas com as mensagens enviadas pelo cliente 132 catch ( ClassNotFoundException classNotFoundException ) { 133 displayArea.append( "\nO tipo de objeto é desconhecido!" ); 134 } } while ( !message.equals( "CLIENTE>>> FIM" ) ); } // end processConnection // Fecha streams e socket 141 private void closeConnection() 142 { 143 displayArea.append( "\nEncerrando conexão\n" ); 144 enterField.setEnabled( false ); // desabilita campo de entrada try { 147 output.close(); 148 input.close(); 149 connection.close(); 150 } Server.java Linhas Linha 141 Lê String do cliente e a mostra Método closeConnection encerra conexão

37 Aplicação Chat – Cliente/Servidor 151 catch( IOException ioException ) { 152 ioException.printStackTrace(); 153 } 154 } // envia mensagem para o cliente 157 private void sendData( String message ) 158 { try { 161 output.writeObject( "SERVIDOR>>> " + message ); 162 output.flush(); 163 displayArea.append( "\nSERVIDOR>>> " + message ); 164 } catch ( IOException ioException ) { 168 displayArea.append( "\nErro ao enviar a mensagem!" ); 169 } 170 } Server.java Linha 62

38 Aplicação Chat – Cliente/Servidor 1 // Client.java 2 // Cliente que lê e envia informação do/ao servidor. 3 import java.io.*; 4 import java.net.*; 5 import java.awt.*; 6 import java.awt.event.*; 7 import javax.swing.*; 8 9 public class Client extends JFrame { 10 private JTextField enterField; 11 private JTextArea displayArea; 12 private ObjectOutputStream output; 13 private ObjectInputStream input; 14 private String message = ""; 15 private String chatServer; 16 private Socket client; // inicializa chatServer e configura GUI 19 public Client( String host ) 20 { 21 super( "Client" ); chatServer = host; // configura servidor a ser conectado Container container = getContentPane(); Client.java Linha 16

39 Aplicação Chat – Cliente/Servidor // cria enterField e registra o listener (evento) 28 enterField = new JTextField(); 29 enterField.setEditable( false ); 30 enterField.addActionListener( 31 new ActionListener() { // envia mensagem ao servidor 34 public void actionPerformed( ActionEvent event ) 35 { 36 sendData( event.getActionCommand() ); 37 enterField.setText( "" ); 38 } 39 } 40 ); container.add( enterField, BorderLayout.NORTH ); // cria displayArea 45 displayArea = new JTextArea(); 46 container.add( new JScrollPane( displayArea ), 47 BorderLayout.CENTER ); setSize( 300, 150 ); 50 setVisible( true ); Client.java

40 Aplicação Chat – Cliente/Servidor } // end Client construtor // conecta-se ao servidor e processa as mensagens 55 private void runClient() 56 { 57 // conecta ao servidor, obtém streams, processa conexão 58 try { 59 connectToServer(); // Passo 1: Cria o Socket para se conectar 60 getStreams(); // Passo 2: Obtêm input and output streams 61 processConnection(); // Passo 3: Processa conexão 62 } // O Servidor encerra a conexão 65 catch ( EOFException eofException ) { 66 System.err.println( O Servidor encerrou a conexão!" ); 67 } // processa problemas com a comunicação 70 catch ( IOException ioException ) { 71 ioException.printStackTrace(); 72 } finally { 75 closeConnection(); // Passo 4: Encerra a conexão 76 } Client.java

41 Aplicação Chat – Cliente/Servidor } // end método runClient // Conecta ao servidor 81 private void connectToServer() throws IOException 82 { 83 displayArea.append( Tentando conectar... \n" ); // cria Socket para se conectar ao servidor 86 client = new Socket( InetAddress.getByName( chatServer ), ); // mostra informações da conexão 89 displayArea.append( "Conectado ao: " + 90 client.getInetAddress().getHostName() ); 91 } // Obtêm streams para enviar e receber dados 94 private void getStreams() throws IOException 95 { 96 // configura output stream 97 output = new ObjectOutputStream( client.getOutputStream() ); 98 output.flush(); // esvazia output buffer // configura input stream 101 input = new ObjectInputStream( client.getInputStream() ); Client.java Linha 86 Linhas Linhas 97 e 101 Cria um cliente que irá se conectar a porta do servidor Notifica ao usuário que ele está conectado Obtêm as streams para enviar e receber dados

42 Aplicação Chat – Cliente/Servidor displayArea.append( "\nObtêm I/O streams\n" ); 104 } // processa conexão com o servidor 107 private void processConnection() throws IOException 108 { 109 // habilita enterField para o cliente enviar mensagens 110 enterField.setEnabled( true ); do { // processa mensagens enviadas pelo servidor // lê a mensagem e a exibe 115 try { 116 message = ( String ) input.readObject(); 117 displayArea.append( "\n" + message ); 118 } // captura problemas de leitura 121 catch ( ClassNotFoundException classNotFoundException ) { 122 displayArea.append( "\nObjeto recebido de tipo desconhecido!" ); 123 } } while ( !message.equals( "SERVIDOR>>> FIM" ) ); } // end método processConnection Client.java

43 Aplicação Chat – Cliente/Servidor // fecha streams e socket 130 private void closeConnection() 131 { 132 displayArea.append( "\nEncerrando conexão!" ); 133 enterField.setEnabled( false ); // disable enterField try { 136 output.close(); 137 input.close(); 138 client.close(); 139 } 140 catch( IOException ioException ) { 141 ioException.printStackTrace(); 142 } 143 } // send message to server 146 private void sendData( String message ) 147 { 148 // send object to server 149 try { 150 output.writeObject( "CLIENTE>>> " + message ); 151 output.flush(); 152 displayArea.append( "\nCLIENTE>>> " + message ); 153 } Método closeConnection encerra a conexão Client.java Linha 130

44 Aplicação Chat – Cliente/Servidor // process problems sending object 156 catch ( IOException ioException ) { 157 displayArea.append( "\nErro ao enviar a mensagem" ); 158 } 159 } public static void main( String args[] ) 200 { 201 Client application; 202 if ( args.length == 0 ) 203 application = new Client( " " ); 204 else 205 application = new Client( args[ 0 ] ); 206 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); 207 application.runClient(); 208 } 209 } // end classe Client Client.java


Carregar ppt "Ronaldo Celso Messias Correia Programação Concorrente Threads."

Apresentações semelhantes


Anúncios Google