Programação Concorrente

Programação Concorrente
Threads Ronaldo Celso Messias Correia

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

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.

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.)

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

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 processador programa programa tarefa2 programa tarefa1 sistema operacional ambiente aplicação Aplicação Java: biblioteca de classes java. lang Thread, ThreadGroup,ThreadLocal, ThreadDeath

Fluxo de execução Execução seqüencial Execução concorrente
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

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 interface Runnable class Applet class MyClass class MyClass

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?

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

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.

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 !!!");

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 um dois tres Quem terminará antes?

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

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

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);

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 !!!");

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(); }

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

Exemplo de sleep Exemplo de Deitel.com quem? dorme! fui interrompida?
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()); quem? dorme! fui interrompida?

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

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

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...)

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)

Sincronismo: exclusão mútua
thread 1 thread 2 public synchronized void recurso (..){ } 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 OBS: Uma classe pode possuir diversos métodos synchronized mas somente um pode estar ativo em um determinado momento

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

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

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

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();

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() );

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 { private JTextField enterField; private JTextArea displayArea; private ObjectOutputStream output; private ObjectInputStream input; private ServerSocket server; private Socket connection; private int counter = 1; 18 // configura GUI public Server() { super( "Servidor" ); 23 Container container = getContentPane(); 25 O listen está sobre o ServerSocket; a conexão é um Socket

// cria compo de entrada e configura o listener (evento) enterField = new JTextField(); enterField.setEditable( false ); enterField.addActionListener( new ActionListener() { 31 // envia mensagem ao cliente public void actionPerformed( ActionEvent event ) { sendData( event.getActionCommand() ); enterField.setText( "" ); } } ); 40 container.add( enterField, BorderLayout.NORTH ); 42 // cria área de display displayArea = new JTextArea(); container.add( new JScrollPane( displayArea ), BorderLayout.CENTER ); 47 setSize( 300, 150 ); setVisible( true ); 50 } // fim Construtor 52 Server.java

// configura e executa o servidor public void runServer() { // configura o servidor para receber conexões; processa as conexões try { 58 // Passo 1: Cria o ServerSocket. server = new ServerSocket( 12345, 100 ); 61 while ( true ) { 63 try { waitForConnection(); // Passo 2: Aguarda conexão. getStreams(); // Passo 3: Obtém input & output streams. processConnection(); // Passo 4: Processa conexão. } 69 // processa EOFException quando o cliente encerra a conexão catch ( EOFException eofException ) { System.err.println( “O Cliente encerrou a conexão!" ); } 74 finally { closeConnection(); // Passo 5: Fecha a conexão. counter; } Server.java Cria ServerSocket para a porta com fila de tamanho 100

79 } // end while 81 } // end try 83 // processa problemas com I/O catch ( IOException ioException ) { ioException.printStackTrace(); } 88 } // end Método runServer 90 // Aguarda os pedidos de conexão, e depois mostra a informação de conexão private void waitForConnection() throws IOException { displayArea.append( “Aguardando por conexões\n" ); connection = server.accept(); // permite o servidor aceitar conexões displayArea.append( "Conexão " + counter + " recebida de : " + connection.getInetAddress().getHostName() ); } 99 // Obtém streams para enviar e receber dados private void getStreams() throws IOException { Server.java Linha 95 Linhas 96-97 Método accept aguarda por conexão Exibe o nome do computador que conectou

// configura output stream output = new ObjectOutputStream( connection.getOutputStream() ); output.flush(); // esvazia buffer de saída 106 // configura input stream input = new ObjectInputStream( connection.getInputStream() ); 109 displayArea.append( "\nI/O streams obtidos!\n" ); } 112 // processa conexão com o cliente private void processConnection() throws IOException { // envia mensagem de conexão bem-sucedida para o cliente String message = "Conexão bem sucedida!"; sendData( message ); 119 // habilita campo de entrada para o usuário do servidor enterField.setEditable( true ); 122 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

// lê as mensagens e as mostra try { message = ( String ) input.readObject(); displayArea.append( "\n" + message ); } 130 // captura problemas com as mensagens enviadas pelo cliente catch ( ClassNotFoundException classNotFoundException ) { displayArea.append( "\nO tipo de objeto é desconhecido!" ); } 135 } while ( !message.equals( "CLIENTE>>> FIM" ) ); 137 } // end processConnection 139 // Fecha streams e socket private void closeConnection() { displayArea.append( "\nEncerrando conexão\n" ); enterField.setEnabled( false ); // desabilita campo de entrada 145 try { output.close(); input.close(); connection.close(); } Server.java Linhas Linha 141 Lê String do cliente e a mostra Método closeConnection encerra conexão

catch( IOException ioException ) { ioException.printStackTrace(); } } 155 // envia mensagem para o cliente private void sendData( String message ) { 159 try { output.writeObject( "SERVIDOR>>> " + message ); output.flush(); displayArea.append( "\nSERVIDOR>>> " + message ); } 165 166 catch ( IOException ioException ) { displayArea.append( "\nErro ao enviar a mensagem!" ); } } 171 172 Server.java Linha 62

// Client.java // Cliente que lê e envia informação do/ao servidor. import java.io.*; import java.net.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; 8 public class Client extends JFrame { private JTextField enterField; private JTextArea displayArea; private ObjectOutputStream output; private ObjectInputStream input; private String message = ""; private String chatServer; private Socket client; 17 // inicializa chatServer e configura GUI public Client( String host ) { super( "Client" ); 22 chatServer = host; // configura servidor a ser conectado 24 Container container = getContentPane(); Client.java Linha 16

26 // cria enterField e registra o listener (evento) enterField = new JTextField(); enterField.setEditable( false ); enterField.addActionListener( new ActionListener() { 32 // envia mensagem ao servidor public void actionPerformed( ActionEvent event ) { sendData( event.getActionCommand() ); enterField.setText( "" ); } } ); 41 container.add( enterField, BorderLayout.NORTH ); 43 // cria displayArea displayArea = new JTextArea(); container.add( new JScrollPane( displayArea ), BorderLayout.CENTER ); 48 setSize( 300, 150 ); setVisible( true ); Client.java

51 } // end Client construtor 53 // conecta-se ao servidor e processa as mensagens private void runClient() { // conecta ao servidor, obtém streams, processa conexão try { connectToServer(); // Passo 1: Cria o Socket para se conectar getStreams(); // Passo 2: Obtêm input and output streams processConnection(); // Passo 3: Processa conexão } 63 // O Servidor encerra a conexão catch ( EOFException eofException ) { System.err.println( “O Servidor encerrou a conexão!" ); } 68 // processa problemas com a comunicação catch ( IOException ioException ) { ioException.printStackTrace(); } 73 finally { closeConnection(); // Passo 4: Encerra a conexão } Client.java

77 } // end método runClient 79 // Conecta ao servidor private void connectToServer() throws IOException { displayArea.append( “Tentando conectar ... \n" ); 84 // cria Socket para se conectar ao servidor client = new Socket( InetAddress.getByName( chatServer ), ); 87 // mostra informações da conexão displayArea.append( "Conectado ao: " + client.getInetAddress().getHostName() ); } 92 // Obtêm streams para enviar e receber dados private void getStreams() throws IOException { // configura output stream output = new ObjectOutputStream( client.getOutputStream() ); output.flush(); // esvazia output buffer 99 // configura input stream input = new ObjectInputStream( client.getInputStream() ); Client.java Linha 86 Linhas 89-90 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

102 displayArea.append( "\nObtêm I/O streams\n" ); } 105 // processa conexão com o servidor private void processConnection() throws IOException { // habilita enterField para o cliente enviar mensagens enterField.setEnabled( true ); 111 do { // processa mensagens enviadas pelo servidor 113 // lê a mensagem e a exibe try { message = ( String ) input.readObject(); displayArea.append( "\n" + message ); } 119 // captura problemas de leitura catch ( ClassNotFoundException classNotFoundException ) { displayArea.append( "\nObjeto recebido de tipo desconhecido!" ); } 124 } while ( !message.equals( "SERVIDOR>>> FIM" ) ); 126 } // end método processConnection Client.java

128 // fecha streams e socket private void closeConnection() { displayArea.append( "\nEncerrando conexão!" ); enterField.setEnabled( false ); // disable enterField 134 try { output.close(); input.close(); client.close(); } catch( IOException ioException ) { ioException.printStackTrace(); } } 144 // send message to server private void sendData( String message ) { // send object to server try { output.writeObject( "CLIENTE>>> " + message ); output.flush(); displayArea.append( "\nCLIENTE>>> " + message ); } Client.java Linha 130 Método closeConnection encerra a conexão

154 // process problems sending object catch ( IOException ioException ) { displayArea.append( "\nErro ao enviar a mensagem" ); } } 160 public static void main( String args[] ) { Client application; if ( args.length == 0 ) application = new Client( " " ); else application = new Client( args[ 0 ] ); application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE ); application.runClient(); } 209 } // end classe Client Client.java

Programação Concorrente

Apresentações semelhantes

Apresentação em tema: "Programação Concorrente"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Programação Concorrente

Apresentações semelhantes

Apresentação em tema: "Programação Concorrente"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback