PROGRAMAÇÃO DISTRIBUÍDA EM JAVA Verão/2001 Aula 01 Noções básicas de redes Threads 29.01.2001 Luciano Silva e-mail: lucianos@ime.usp.br 1

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

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.

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.

CAMADAS DO MODELO ISO OSI Processo A Máquina 1 Máquina 2 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

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

Camada 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

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

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

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

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.

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.

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

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.

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) receive(remetente,mensagem) Enlace Física

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.

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.

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

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 ?

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

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)

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 Escrita Leitura PRODUTOR CONSUMIDOR

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

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)

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

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.

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

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.

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.

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

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)

Exemplo 1 ( Métodos básicos ) class processos implements 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”);

Exemplo 2 ( Prioridades ) class prioridade implements Runnable{ int vezes=0; // Contador de execuções private 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();

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

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.

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

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

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

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.

Exemplo ( Definição do recurso ) class recurso{ int n; // Recurso é uma variávei inteira boolean produziu=false; // 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){...} 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(); this.n=n; produziu=true;

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

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

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 }