PROGRAMA

1
PROGRAMAÇÃO DISTRIBUÍDA EM JAVAVerão/2001

• Aula 01
• Noções básicas de redes
• Threads
• 29.01.2001
• Luciano Silva
• e-mail lucianos_at_ime.usp.br

1
2
Tó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 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
PROTOCOLOS

• 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 OSI
Máquina 1 Máquina 2
Processo A
Processo B
Protocolo de Aplicação
7 6 5 4 3 2 1
Aplicação
Aplicação
Protocolo de Apresentação
Apresentação
Apresentação
Protocolo de Sessão
Sessão
Sessão
Protocolo de Transporte
Transporte
Transporte
Protocolo de Rede
Rede
Rede
Protocolo de Enlace
Enlace de Dados
Enlace de Dados
Protocolo Físico
Física
Física
Rede
6
Formato típico de uma mensagem no modelo ISO OSI
Trailer da camada de enlace
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
7
Camada Física

• A camada física está relacionada com a
  transmissão de 0s e 1s. 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 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 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 Transporte

• A 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ã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çã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çã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-servidor

• A 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
Camadas
Request
Cliente Servidor
7 6 5 4 3 2 1
Reply
microkernel microkernel
Request/Reply
Rede
Devido à simplicidade, as chamadas de comunicação
podem ser reduzidas a send(destino,mensagem) r
eceive(remetente,mensagem)
Enlace
Física
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.

escalonador
PRONTO
ATIVO
time-out
realização da operação de E/S ou comando para
pronto
solicitação de operação de E/S ou comando
de suspensão
SUSPENSO
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
Leitura
Escrita
PRODUTOR
CONSUMIDOR
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 rRuntime.getRuntime()
• Process pnull
• try
• pr.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
  dormindopor
• 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 processos
• implements Runnable
• processos() // Construtor
• Thread principalThread.currentThread() //
  Pega thread corrente
• Thread subordinadonew Thread(this,subordinad
  o)//Instancia novo thread
• System.out.println(Thread subordinadosubord
  inado)
• subordinado.start() //Inicia execução do
  thread subordinado
• public void run() // Método de execução dos
  threads
• try
• for(int i0ilt20i)
• System.out.println(ii)
• 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 prioridade
• implements Runnable
• int vezes0 // Contador de execuções
• private Thread atual
• private boolean executandotrue
• public prioridade(int prio) // Construtor
• atualnew 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
• executandofalse
• public void start() // Método de início do
  thread

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 altanew prioridade(Thread.NORM_PRI
  ORITY2) // Prioridade 7
• prioridade baixa new prioridade(Thread.NORM_P
  RIORITY-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.ss
• 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
• Oianóis aquitraveis.

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 inteira
• boolean produziufalse // Se não alterou
  variáveil n, fica false
• synchronized int le() // lê valor de n
• if(!produziu) // Se n não foi alterada
• try wait() // Espera produzir
• catch(InterruptedException e)...
• catch(IllegalMonitorException e)...
• produziufalse
• 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.nn
• produziutrue

41
Exemplo ( thread produtor)

• class produtor
• implements Runnable
• recurso r
• produtor(recurso r) // Construtor do
  produtor
• this.rr
• (new Thread(this,PRODUTOR)).start()
• public void run()
• int n0
• while(true)
• r.altera(n)

42
Exemplo ( thread consumidor)

• class consumidor
• implements Runnable
• recurso r
• consumidor(recurso r) // Construtor do
  consumidor
• this.rr
• (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 recnew 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