1

PROGRAMAÇÃO PROGRAMAÇÃO DISTRIBUÍDA EM JAVADISTRIBUÍDA EM JAVA

Verão/2001Verão/2001

Aula 01Noções básicas de redes

Threads

29.01.2001Luciano Silva

e-mail: lucianos@ime.usp.br

2

Tópicos da Aula 01Tópicos da Aula 01 Noções básicas de redes Conceitos básicos de processos Concorrência e semáforos Classes Runtime e Process Threads Interface Runnable Threads concorrentes Comunicação entre threads

3

Modelo ISO OSIModelo ISO OSI

O modelo ISO OSI (Open Systems Interconnection Reference Model) é um modelo de referência para comunicação em redes, que identifica os vários níveis envolvidos, dando-lhes nomes específicos e indicando qual a função dos vários níveis.

O modelo foi projetado para permitir a intercomunicação entre sistemas abertos, usando regras-padrão que governam o formato, conteúdo e significado das mensagens enviadas e recebidas. Estas regras são chamadas de protocolos.

4

PROTOCOLOSPROTOCOLOS

O modelo ISO OSI distingue dois tipos gerais de protocolos:

orientados a conexão (connection-oriented): antes de trocar dados, o remetente e destinatário primeiramente estabelecem uma conexão, possivelmente negociando o protocolo a ser usado. Transmitem dados e encerram a conexão.

não orientados a conexão (connectionless): O remetente simplesmente transmite a primeira mensagem quando está pronto.

5

CAMADAS DO MODELO ISO CAMADAS DO MODELO ISO OSIOSI

Aplicação

Apresentação

Sessão

Transporte

Rede

Enlace de Dados

Física

Aplicação

Apresentação

Sessão

Transporte

Rede

Enlace de Dados

FísicaRede

Protocolo de Aplicação

Protocolo de Apresentação

Protocolo de Sessão

Protocolo de Transporte

Protocolo de Rede

Protocolo de Enlace

Protocolo Físico

7

6

5

4

3

2

1

Processo A Processo BMáquina 1 Máquina 2

6

Formato típico de uma mensagem no modelo ISO OSI

Mensagem

Header da camada de Aplicação

Header da camada de Apresentação

Header da camada de Sessão

Header da camada de Transporte

Header da camada de Rede

Header da camada de Enlace

Trailer da camada de enlace

7

Camada FísicaCamada Física

A camada física está relacionada com a transmissão de 0’s e 1’s. São tarefas desta camada:

determinar quantos bits por segundo serão enviados

determinar se a transmissão pode ser feita em ambas a direções simultaneamente

armazenar informações sobre o tamanho e formato do conector de rede, bem como o número de pinos e significado de cada um deles

8

Camada de Enlace de DadosCamada de Enlace de Dados

A camada de enlace de dados ( Data Link ) está relacionada com o agrupamento de bits em unidades chamados frames e verificar se cada um deles foi corretamente recebido.

Esta verificação pode ser feita com base nos padrões de bits presentes no início e final de cada frame. Este padrão é formado fazendo-se alguns cálculos com bits, formado um resultado para verificação ( checksum ).

9

Camada de RedeCamada de Rede

A camada de rede está relacionada principalmente com o roteamento de uma mensagem pela rede. Este roteamento envolve a tentativa de escolha do melhor caminho para enviar a mensagem.

Existem dois protocolos principais para esta camada: X.25 , orientado a conexão IP ( Internet Protocol ), não orientado a conexão

10

Camada de TransporteCamada de TransporteA camada de transporte está relacionada com controle de

recebimento de pacotes de mensagens. Recebida uma mensagem da camada de sessão, a camada de

transporte quebra a mensagem em pedaços o suficiente para que caibam num pacote, assinala a cada um um número sequencial e os envia.

São protocolos típicos desta camada: TCP ( Transmission Control Protocol ), que é orientado a

conexão, muitas vezes utilizado com a combinação TCP/IP UDP ( Universal Datagram Protocol ), que não é

orientado a conexão

11

Camada de SessãoCamada de Sessão

A camada de sessão está relacionada principalmente com o controle do diálogo entre as máquinas, saber que está falando e prover facilidades para sincronização.

12

Camada de ApresentaçãoCamada de Apresentação

A camada de apresentação está relacionada com o significado dos bits. A maioria das mensagens não consistem somente de seqüências aleatórias de bits, mas estruturada de forma mais complexa. Nesta camada é possível definir registros contendo campos e adicionar informações sobre a estruturação destes registros. Isto permite que máquinas com diferentes representações internas se comuniquem.

13

Camada de AplicaçãoCamada de Aplicação

A camada de aplicação é uma coleção de vários protolos para atividades comuns, tais como correio eletrônico, transmissão de arquivos, conexão remota, etc. São protocolos típicos desta camada:

HTTP ( HyperText Transfer Protocol ), protocolo para transferência de hipertexto

FTP ( File Transfer Protocol ), protocolo para transferência de arquivos

TELNET, para conexão remota

14

O modelo cliente-servidorO modelo cliente-servidorA idéia por trás do modelo cliente-servidor é estruturar

o sistema operacional(microkernel) como grupo de processos cooperantes, chamados servidores, que oferecem serviços aos processos usuários, chamados clientes.

As máquinas clientes e servidoras normalmente rodam sobre o mesmo microkernel. Para evitar a complexidade dos protocolos do modelo ISO OSI, tais como TCP/IP, o modelo cliente servidor é usualmente é baseado em um protocolo simples do tipo request/reply, não orientado a conexão.

15

Estrutura do modelo cliente-servidor

Cliente Servidor

microkernel microkernel

Request

Reply

RedeRequest/Reply

Enlace

Física

Camadas

7

6

5

4

3

2

1

Devido à simplicidade, as chamadas decomunicação podem ser reduzidas a:

send(destino,mensagem)receive(remetente,mensagem)

16

PROCESSOS

Processos (ou tarefas) são instâncias de um programa. De um mesmo programa, pode-se ter vários processos.

Uma das principais tarefas de um sistema operacional(SO) é controlar processos. Sistemas operacionais que conseguem controlar somente um processo são chamados de sistemas do tipo monotarefa. Sistemas que podem controlar mais de um processo simultaneamente são chamados de sistemas do tipo multitarefa.

17

CONTROLE DE PROCESSOS

Processos são controlados por um sistema operacional a partir de informações contidas numa estrutura chamada BCP ( Bloco de Controle de Processo). Para cada processo existe uma BCP.

Na BCP estão estruturadas várias informações dos processos, tais como pid, ppid, registradores, ponteiros de instruções, etc.

18

ESTADOS DE UM PROCESSO

Um processo pode estar num dos seguintes três estados: pronto, ativo e suspenso.

PRONTO ATIVO

SUSPENSO

escalonador

time-out

solicitação deoperaçãode E/S oucomando desuspensão

realização daoperação deE/S ou comandopara pronto

19

CONCORRÊNCIA

A quantidade de recursos de um sistema (discos, impressora, etc) é muito menor do que a quantidade de processos que podem acessar estes recursos.

O principal problema desta situação ocorre quando dois ou mais processos tentam acessar concorrentemente um determinado recurso. Como o sistema operacional pode gerenciar acesso concorrente ?

20

CONTROLE DE CONCORRÊNCIA

Existem várias maneiras de se controlar concorrência de processos. Algumas dos mecanismos mais comuns são:

semáforos monitores procedimentos test_and_set

21

SEMÁFOROS

Semáforos baseiam-se em estruturas para contagem de acessos concorrentes, geralmente implementados por variáveis inteiras.

Semáforos são manipulados por dois procedimentos: wait(Semáforo s)

signal(Semáforo s)

22

EXEMPLO PARA USO DE SEMÁFOROS

Considere-se um vetor V que é acessado de dois modos: um processo que grava em V e outro que lê informações de V.

V

PRODUTOR CONSUMIDOR

LeituraEscrita

23

SEMÁFOROS PARA O EXEMPLO ANTERIOR

wait(MUTEX) wait(PRODUZIU)

altera vetor V wait(MUTEX)

signal(MUTEX) lê dado de V

signal(PRODUZIU) signal(MUTEX)

PRODUTOR CONSUMIDOR

24

PROCESSOS EM JAVA

Java já possui uma série de recursos para disparar e gerenciar processos. É possível com estes mecanismos:

obter o processo de execução do interpretador Java

chamar comandos específicos de um sistema operacional

lançar e controlar lightweight processes com estado reduzido( threads)

25

CLASSE Runtime

Classe de Java que representa e gerencia o sistema Java em execução.

Não se pode instanciar o objeto do tipo Runtime, pois ele já foi instanciado pelo interpretador Java. Porém, pode-se conseguir uma referência do processo em execução, através do método

getRuntime()

26

CLASSE Process

Classe de Java que representa um processo. Esta classe não tem construtor, pois trata de um objeto externo, ou seja, de um processo que não é criado dentro do Runtime Java.

A classe Process ajuda a manipular um processo, bem como gerenciá-lo.

27

Exemplo com classe Runtime e Process

class chama_comando_SO{public static void main(String args[]){ Runtime r=Runtime.getRuntime(); Process p=null; try{

p=r.exec(“/usr/bin/ls”); // chama ls do Unix p.waitFor(); // Faz p esperar pelo final do ls } catch(Exception e){...} if(p.exitValue()==0) // Verifica código de retorno do processo

System.out.println(“Tudo OK com ls”); else System.out.println(“ls deu algum erro”);}

}

28

THREADS

Threads são processos leves (lightweight process) com um estado reduzido. O estado reduzido advém do fato de um grupo de threads compartilharem os mesmos dados.

Em um sistema com threads, um processo com exatamente um thread é equivalente a um processo clássico. Cada thread pertence a exatamente um processo, compartilhando os dados do processo que o disparou. Threads não podem existir fora de um processo.

29

Interface Runnable

Toda classe que precisa manipular threads, deve primeiramente implementar o método:

public void run();

definido na interface Runnable. Este método define o que o thread disparado pela classe deverá fazer.

30

CLASSE Thread

Classe utilizada para instanciar threads. Instanciar não significa que o thread começará a ser executado.

Existem, basicamente, três construtores para threads:

Thread() construtor-padrão

Thread(String n) construtor com nome do thread

Thread(ThreadGroup g,String n) construtor com base num

grupo de threads e nome n

31

Alguns métodos iniciais da classe

boolean isAlive() verifica se thread está ativo

boolean isDaemon() verifica se thread é um daemon

void start() inicia a execução do thread

void stop() para o thread

void supend() suspende o thread

void resume() retoma thread suspenso

void sleep(long t) deixa thread “dormindo”por

t milisegundos

void setName(String s) muda nome do thread

void setPriority(int p) altera prioridade de execução

( 1 - mínima 10 - máxima)

32

Exemplo 1 ( Métodos básicos )

class processosimplements Runnable{

processos(){ // Construtor Thread principal=Thread.currentThread(); // Pega thread corrente Thread subordinado=new Thread(this,”subordinado”);//Instancia novo thread System.out.println(“Thread subordinado=“+subordinado); subordinado.start(); //Inicia execução do thread subordinado}

public void run(){ // Método de execução dos threads try{

for(int i=0;i<20;i++){ System.out.println(“i=“+i); Thread.sleep(1000); // Deixa thread dormindo durante 1 segundo}

} catch(InterruptedException e){ // Recuperação da exceção de interrupção do thread System.out.println(“Thread interromprido”); }}

}

33

Exemplo 2 ( Prioridades )

class prioridadeimplements Runnable{

int vezes=0; // Contador de execuçõesprivate Thread atual;private boolean executando=true;

public prioridade(int prio){ // Construtor atual=new Thread(this); atual.setPriority(prio); // Altera prioridade do Thread}public void run() { // Método de execução while(executando) vezes++;}public void stop(){ // Método de parada do thread executando=false;}public void start(){ // Método de início do thread atual.start();}

}

34

Exemplo 2 ( Continuação )

class testeprioridade{

public static void main(String args[]){

Thread.currentThread().setPriority(Thread.MAX_PRIORITY); // Prioridade 10 para thread corrente

prioridade alta=new prioridade(Thread.NORM_PRIORITY+2); // Prioridade 7

prioridade baixa= new prioridade(Thread.NORM_PRIORITY-2); // Prioridade 3

baixa.start(); // Coloca primeiro o de baixa prioridade na fila de processos

alta.start();

try{

Thread.sleep(10000); // Faz thread corrente dormir por 10 segundos

}

catch(InterruptedException e){...}

baixa.stop();

alta.stop();

}

}

35

Threads concorrentes

Threads podem também acessar recursos concorrentemente, como por exemplo, chamar o método System.out.println.

Se um thread utiliza algum método que possa fazer acesso concorrente, há necessidade de sincronizar tal método.

36

Exemplo 1 ( Sem sincronização)

class concorrente

implements Runnable{

String s;

concorrente(String s){ // Construtor

this.s=s;

new Thread(this).start();

}

void imprime(){ // Imprime a string do objeto

System.out.print(“[“+s);

try Thread.sleep(1000); // Coloca Thread para dormir durante 1 segundo

catch(InterruptedException e){ ...};

System.out.println(“]”);

}

public void run(){ // Método de execução dos threads

imprime();

}

}

37

Exemplo 1 ( continuação)

class exemplo{

public static void main(String args[]){

new concorrente(“Oia”);

new concorrente(“nóis aqui”);

new concorrente(“traveis.”);

}

}

O resultado desta execução seria algo do tipo:

[Oia[nóis aqui[traveis.]

]

]

38

Solução do problema de concorrência do exemplo 1

A origem do problema do do exemplo 1 está no acesso concorrente à System.out, uma vez que os threads foram “dormir” sem acabar de produzir toda a saída.

A solução para isto é definir o método imprimir sincronizado.

synchronized void imprime();

39

Comunicação entre threads

Em Java, threads podem se comunicar através dos seguintes métodos:

wait() throws InterruptedException, IllegalMonitorStateException: indica ao thread que ele deve desistir de um recursos até que seja notificado por outro thread.

notify() throws IllegalMonitorStateException: torna pronto o primeiro thread que chamou wait() para o recurso.

notifyAll() throws IllegalMonitorStateException: torna prontos todos os thread que chamaram wait() para o

recurso.

40

Exemplo ( Definição do recurso )

class recurso{int n; // Recurso é uma variávei inteiraboolean produziu=false; // Se não alterou variáveil n, fica falsesynchronized int le(){ // lê valor de n if(!produziu) // Se n não foi alterada try wait(); // Espera produzir catch(InterruptedException e){...} catch(IllegalMonitorException e){...} produziu=false; notify(); return(n); }

synchronized void altera(int n){ // Altera valor de n if(produziu) // Alteração colocada anteriormente, porém ainda não lida try wait(); catch(InterruptedException e){...} catch(IllegalMonitorException e){...} this.n=n; produziu=true; notify();}

}

41

Exemplo ( thread produtor)

class produtor

implements Runnable{

recurso r;

produtor(recurso r){ // Construtor do produtor

this.r=r;

(new Thread(this,”PRODUTOR”)).start();

}

public void run(){

int n=0;

while(true)

r.altera(n);

}

}

42

Exemplo ( thread consumidor)

class consumidor

implements Runnable{

recurso r;

consumidor(recurso r){ // Construtor do consumidor

this.r=r;

(new Thread(this,”CONSUMIDOR”)).start();

}

public void run(){

while(true)

System.out.println(“Lido dado “+r.le());

}

}

43

Exemplo ( utilização do produtor e consumidor)

class utilizacao{

public static void main(String args[]){

recurso rec=new recurso(); // recurso a ser compartilhado pelo produtor e pelo consumidor

new produtor(rec); // inicializa produtor com recurso rec

new consumidor(rec); // inicializa consumidor com recursos rec

}

}