unesp

Ronaldo Celso Messias Correiaronaldo@fct.unesp.br

Programação Concorrente

Threads

unespServidores Concorrentes

Aguarda pedido

Trata pedido

Início Início

Aguarda pedido

cria uma threadtratadora e volta

Responde Trata pedido

Responde

tratadortermina

Trata pedido

Responde

tratadortermina

Trata pedido

Responde

tratadortermina

...

pedido

resposta

resp. resp.

pedido

SeqüencialSeqüencial ConcorrenteConcorrente

resp.

unespProgramaçã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.

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

unespAlgumas 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

unespProgramaçã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

programaprograma

programa tarefa2

tarefa1

Aplicação Java: biblioteca de

classes java. lang Thread,

ThreadGroup,ThreadLocal,

ThreadDeath

unespFluxo de execução

Execução seqüencialComandos 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çõesPrograma controla a ordem

de execução

Execução concorrenteCada 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

unespCriaçã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 MyClassclass Applet

interface Runnable

class MyClass

unespExecuçã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?

unespClasse Thread

Usada quando a classe a ser executada concorrentemente não deriva de outra classe

Contém métodos para controlar a execuçãoCriaçã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

unespContexto da classe Thread

java.lang.Object

java.lang.Thread

public class Threadextends Objectimplements 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.

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

}}

unespExemplo 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?

unespResultado de uma execução

*** LARGADA ****** LARGADA ****** LARGADA *** Primeira volta:Rubinho Primeira volta:Schumacher Primeira volta:HakkinnenRubinho -> Terminou a Corrida !!!Hakkinnen -> Terminou a Corrida !!!Schumacher -> Terminou a Corrida !!!

CorridaT

um dois tres

unespResultado de outra execução

*** LARGADA *** Primeira volta:RubinhoRubinho -> Terminou a Corrida !!!*** LARGADA *** Primeira volta:Schumacher*** LARGADA ***Schumacher -> Terminou a Corrida !!! Primeira volta:HakkinnenHakkinnen -> Terminou a Corrida !!!

CorridaT

um dois tres

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

unesp

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

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

}

}

unespEstados de Threads

newblocked

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

unespExemplo de sleep

class PrintThread extends Thread { private int sleepTime; public PrintThread (String name) { // construtor

super(nome); // nome do thread: construtor de TreadsleepTime=(int)(Math.random() * 5000); // 0-5 secSystem.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?

unespExceçã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

unespExemplo 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

unespPrioridades

Cada thread possui uma prioridade (entre 1 e 10)

Default: prioridade = 5Prioridade transmitida

por herançaThreads 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...)

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

unespSincronismo: 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 1 thread 2

public synchronized voidrecurso (..){................}

OBS: Uma classe pode possuir diversos métodos synchronized mas somente um pode estar ativo em um determinado momento

unespLista 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

unesp

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 tempoO 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

unesp

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 tempoO 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

unespServidor 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 conexaocliente = ss.accept();

// Cria uma thread para cada requisiçãoconexao = new Conexao(cliente);conexao.start();

} }

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

}

unespAplicação Chat – Cliente/Servidor1 // Server.java2 // 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;18 19 // configura GUI20 public Server()21 {22 super( "Servidor" );23 24 Container container = getContentPane();25

O listen está sobre o ServerSocket; a

conexão é um Socket

unespAplicação Chat – Cliente/Servidor26 // cria compo de entrada e configura o listener (evento)27 enterField = new JTextField();28 enterField.setEditable( false );29 enterField.addActionListener(30 new ActionListener() {31

32 // envia mensagem ao cliente33 public void actionPerformed( ActionEvent event )34 {35 sendData( event.getActionCommand() );36 enterField.setText( "" );37 }38 } 39 ); 40

41 container.add( enterField, BorderLayout.NORTH );42

43 // cria área de display44 displayArea = new JTextArea();45 container.add( new JScrollPane( displayArea ), 46 BorderLayout.CENTER );47

48 setSize( 300, 150 );49 setVisible( true );50

51 } // fim Construtor52

Server.java

unespAplicação Chat – Cliente/Servidor53 // configura e executa o servidor 54 public void runServer()55 {56 // configura o servidor para receber conexões; processa as conexões57 try {58

59 // Passo 1: Cria o ServerSocket.60 server = new ServerSocket( 12345, 100 );61

62 while ( true ) {63

64 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 }69

70 // processa EOFException quando o cliente encerra a conexão71 catch ( EOFException eofException ) {72 System.err.println( “O Cliente encerrou a conexão!" );73 }74

75 finally {76 closeConnection(); // Passo 5: Fecha a conexão.77 ++counter;78 }

Cria ServerSocket para a porta 12345

com fila de tamanho 100

Server.java

unespAplicação Chat – Cliente/Servidor79

80 } // end while81

82 } // end try83

84 // processa problemas com I/O85 catch ( IOException ioException ) {86 ioException.printStackTrace();87 }88

89 } // end Método runServer90

91 // Aguarda os pedidos de conexão, e depois mostra a informação de conexão92 private void waitForConnection() throws IOException93 {94 displayArea.append( “Aguardando por conexões\n" );95 connection = server.accept(); // permite o servidor aceitar conexões96 displayArea.append( "Conexão " + counter + " recebida de : " +97 connection.getInetAddress().getHostName() );98 }99

100 // Obtém streams para enviar e receber dados101 private void getStreams() throws IOException102 {

Server.java

Linha 95Linhas 96-97

Método accept aguarda por conexão

Exibe o nome do computador que

conectou

unespAplicação Chat – Cliente/Servidor103 // configura output stream104 output = new ObjectOutputStream( connection.getOutputStream() ); 105 output.flush(); // esvazia buffer de saída106

107 // configura input stream108 input = new ObjectInputStream( connection.getInputStream() );109

110 displayArea.append( "\nI/O streams obtidos!\n" );111 }112

113 // processa conexão com o cliente114 private void processConnection() throws IOException115 {116 // envia mensagem de conexão bem-sucedida para o cliente117 String message = "Conexão bem sucedida!";118 sendData( message );119

120 // habilita campo de entrada para o usuário do servidor121 enterField.setEditable( true );122

123 do { // processa mensagens enviadas pelo cliente124

Server.java

Linha 105

Método flush descarrega buffer de

saída para enviar cabeçalho de informação

unespAplicação Chat – Cliente/Servidor125 // lê as mensagens e as mostra126 try {127 message = ( String ) input.readObject();128 displayArea.append( "\n" + message );129 }130 131 // captura problemas com as mensagens enviadas pelo cliente132 catch ( ClassNotFoundException classNotFoundException ) {133 displayArea.append( "\nO tipo de objeto é desconhecido!" );134 }135 136 } while ( !message.equals( "CLIENTE>>> FIM" ) );137 138 } // end processConnection139 140 // Fecha streams e socket141 private void closeConnection() 142 {143 displayArea.append( "\nEncerrando conexão\n" );144 enterField.setEnabled( false ); // desabilita campo de entrada145 146 try {147 output.close(); 148 input.close(); 149 connection.close();150 }

Server.java

Linhas 127-128

Linha 141

Lê String do cliente e a mostra

Método closeConnection

encerra conexão

unespAplicação Chat – Cliente/Servidor151 catch( IOException ioException ) {152 ioException.printStackTrace();153 }154 }155 156 // envia mensagem para o cliente157 private void sendData( String message )158 {159160 try {161 output.writeObject( "SERVIDOR>>> " + message );162 output.flush(); 163 displayArea.append( "\nSERVIDOR>>> " + message );164 }165 166167 catch ( IOException ioException ) {168 displayArea.append( "\nErro ao enviar a mensagem!" );169 }170 }171 172

Server.java

Linha 62

unespAplicação Chat – Cliente/Servidor1 // Client.java2 // 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;17 18 // inicializa chatServer e configura GUI19 public Client( String host )20 {21 super( "Client" );22 23 chatServer = host; // configura servidor a ser conectado24 25 Container container = getContentPane();

Client.java

Linha 16

unespAplicação Chat – Cliente/Servidor26 27 // cria enterField e registra o listener (evento)28 enterField = new JTextField();29 enterField.setEditable( false );30 enterField.addActionListener(31 new ActionListener() {32 33 // envia mensagem ao servidor34 public void actionPerformed( ActionEvent event )35 {36 sendData( event.getActionCommand() );37 enterField.setText( "" );38 }39 } 40 ); 41 42 container.add( enterField, BorderLayout.NORTH );43 44 // cria displayArea45 displayArea = new JTextArea();46 container.add( new JScrollPane( displayArea ),47 BorderLayout.CENTER );48 49 setSize( 300, 150 );50 setVisible( true );

Client.java

unespAplicação Chat – Cliente/Servidor51 52 } // end Client construtor53 54 // conecta-se ao servidor e processa as mensagens55 private void runClient() 56 {57 // conecta ao servidor, obtém streams, processa conexão58 try {59 connectToServer(); // Passo 1: Cria o Socket para se conectar60 getStreams(); // Passo 2: Obtêm input and output streams61 processConnection(); // Passo 3: Processa conexão62 }63 64 // O Servidor encerra a conexão65 catch ( EOFException eofException ) {66 System.err.println( “O Servidor encerrou a conexão!" );67 }68 69 // processa problemas com a comunicação70 catch ( IOException ioException ) {71 ioException.printStackTrace();72 }73 74 finally {75 closeConnection(); // Passo 4: Encerra a conexão76 }

Client.java

unespAplicação Chat – Cliente/Servidor77 78 } // end método runClient79 80 // Conecta ao servidor81 private void connectToServer() throws IOException82 { 83 displayArea.append( “Tentando conectar ... \n" );84 85 // cria Socket para se conectar ao servidor86 client = new Socket( InetAddress.getByName( chatServer ), 12345 );87 88 // mostra informações da conexão89 displayArea.append( "Conectado ao: " + 90 client.getInetAddress().getHostName() );91 }92 93 // Obtêm streams para enviar e receber dados94 private void getStreams() throws IOException95 {96 // configura output stream 97 output = new ObjectOutputStream( client.getOutputStream() ); 98 output.flush(); // esvazia output buffer99 100 // configura input stream101 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 12345 do servidor

Notifica ao usuário que ele está conectado

Obtêm as streams para enviar e receber

dados

unespAplicação Chat – Cliente/Servidor102 103 displayArea.append( "\nObtêm I/O streams\n" );104 }105 106 // processa conexão com o servidor107 private void processConnection() throws IOException108 {109 // habilita enterField para o cliente enviar mensagens110 enterField.setEnabled( true );111 112 do { // processa mensagens enviadas pelo servidor113 114 // lê a mensagem e a exibe115 try {116 message = ( String ) input.readObject();117 displayArea.append( "\n" + message );118 }119 120 // captura problemas de leitura121 catch ( ClassNotFoundException classNotFoundException ) {122 displayArea.append( "\nObjeto recebido de tipo desconhecido!" );123 }124 125 } while ( !message.equals( "SERVIDOR>>> FIM" ) );126 127 } // end método processConnection

Client.java

unespAplicação Chat – Cliente/Servidor128 129 // fecha streams e socket130 private void closeConnection() 131 {132 displayArea.append( "\nEncerrando conexão!" );133 enterField.setEnabled( false ); // disable enterField134 135 try {136 output.close();137 input.close(); 138 client.close();139 }140 catch( IOException ioException ) {141 ioException.printStackTrace();142 }143 }144 145 // send message to server146 private void sendData( String message )147 {148 // send object to server149 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

unespAplicação Chat – Cliente/Servidor154 155 // process problems sending object156 catch ( IOException ioException ) {157 displayArea.append( "\nErro ao enviar a mensagem" );158 }159 }160 199 public static void main( String args[] )200 {201 Client application;202 if ( args.length == 0 )203 application = new Client( "127.0.0.1" );204 else205 application = new Client( args[ 0 ] );206 application.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );207 application.runClient();208 }209 } // end classe Client

Client.java