Programação Concorrente - Aula 05

ANHANGUERA – 2016.1
PROGRAMAÇÃO CONCORRENTE
AULA 05 – COMUNICAÇÃO ENTRE PROCESSOS
Prof. Thomás da Costa
thomascosta@aedu.com

PROGRAMAÇÃO CONCORRENTE – Prof. Thomás da Costa
COMUNICAÇÃO ENTRE PROCESSOS

Comunicação Entre Processos
O que é?:
É a troca de informações ou mensagens entre programas, localizados no
mesmo computador ou em computadores diferentes. Essa comunicação pode
acontecer também em redes diferentes.

Comunicação Entre Processos
Tipos de comunicação que vamos estudar:
• Arquivos compartilhados utilizando Serialização de objetos em Java.
• Comunicação Socket via TCP/IP.

Arquivos Compartilhados
Detalhes:
• Um arquivo fica localizado em um diretório.
• Programas podem acessar este arquivo para compartilhar informações.
• Vamos utilizar o conceito de serialização de classes em Java.
• Neste processo, o arquivo contém os bytecodes de uma classe.
• Para que ocorra a serialização, uma classe deve implementar a interface
Serializable.
• A classe que implementa a interface Serializable é um POJO que possui
somente atributos com getter e setters.
• Não vamos nos preocupar com acessos simultâneos no arquivo.

package edu.anhanguera.prc.aula05;
import java.io.Serializable;
public class Pessoa implements Serializable {
private static final long serialVersionUID = -8617059067424820303L;
private String nome;
private int idade;
private double altura;
private double peso;
public Pessoa() {
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public int getIdade() {
return idade;
}
public void setIdade(int idade) {
this.idade = idade;
}
public double getAltura() {
return altura;
}
public void setAltura(double altura) {
this.altura = altura;
}
public double getPeso() {
return peso;
}
public void setPeso(double peso) {
this.peso = peso;
}
}

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
public class SerializandoObjeto {
public static void main(String[] args) {
Pessoa pessoa = new Pessoa();
FileOutputStream fileOutputStream = null;
ObjectOutputStream objectOutputStream = null;
try {
pessoa.setAltura(1.75);
pessoa.setIdade(31);
pessoa.setNome("Bruce Wayne");
pessoa.setPeso(85.45);
fileOutputStream = new FileOutputStream("/tmp/pessoa.obj");
objectOutputStream = new ObjectOutputStream(fileOutputStream);
objectOutputStream.writeObject(pessoa);
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fileOutputStream.close();
objectOutputStream.close();
} catch (Exception e) {}
}
}
}

import java.io.FileInputStream;
import java.io.ObjectInputStream;
public class DeserializandoObjeto {
Pessoa pessoa = null;
FileInputStream fileInputStream = null;
ObjectInputStream objectInputStream = null;
try {
fileInputStream = new FileInputStream("/tmp/pessoa.obj");
objectInputStream = new ObjectInputStream(fileInputStream);
pessoa = (Pessoa) objectInputStream.readObject();
System.out.println(pessoa.getAltura());
System.out.println(pessoa.getIdade());
System.out.println(pessoa.getNome());
System.out.println(pessoa.getPeso());
} finally {
try {
fileInputStream.close();
objectInputStream.close();
} catch (Exception e) {}
}
}
}

Arquivos Compartilhados
Detalhes:
• Utilizamos a classe FileOutputStream para criar um arquivo em um
diretório.
• A classe ObjectOutputStream grava o objeto Pessoa no arquivo
especificado.
• Este processo acontece a Serialização do objeto.
• Para Deserializar o objeto, utilizamos o FileInputStream para efetuar a
leitura do arquivo e ObjectInputStream para criar o objeto Pessoa.
• É necessário efetuar um cast para o tipo especificado.

Sockets
Detalhes:
• Comunicação entre processos localizados normalmente em computadores
diferentes.
• Utilizamos a rede para o envio de informações entre um processo e outro.
• Esta comunicação acontece via TCP/IP.
• É necessário conhecer o endereço e a porta do processo destino para que
ocorra a comunicação.
• Existe uma padronização feita pelo cliente e servidor para que ocorra a
troca de informações.

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class Servidor {
ServerSocket servidor = null;
try {
System.out.println("[SERVER] - Iniciando Servidor na porta 1234...");
servidor = new ServerSocket(1234);
System.out.println("[SERVER] - Servidor Iniciado");
while (true) {
System.out.println("[SERVER] - Aguardando conexão.");
Socket cliente = servidor.accept();
System.out.println("[SERVER] - Conexão Recebida de " +
cliente.getInetAddress().getHostAddress());
ProcessamentoThread processThread = new ProcessamentoThread();
processThread.setSocket(cliente);
Thread thread = new Thread(processThread);
thread.start();
System.out.println("[SERVER] - Thread de processamento em execução.");
}
} catch (IOException e) {
} finally {
try {
servidor.close();
} catch (IOException e) {}
}
}
}

Sockets
Detalhes:
• Neste exemplo, estamos criando uma comunicação cliente-servidor.
• Utilizamos a classe ServerSocket para criar um servidor que irá receber
conexões de seus clientes.
• Este servidor é executado na porta 1234.
• Para cada conexão, criamos uma Thread para paralelizar o processamento
das informações.

import java.util.Scanner;
public class ProcessamentoThread implements Runnable {
private Socket cliente = null;
public void run() {
System.out.println("[PROCESSO] - Executando processamento do cliente " +
cliente.getInetAddress().getHostAddress());
Scanner scanner = null;
try {
scanner = new Scanner(cliente.getInputStream());
while (scanner.hasNextLine()) {
System.out.println("[PROCESSO] - Mensagem Recebida: " +
scanner.nextLine());
}
} catch (IOException e) {
} finally {
scanner.close();
}
}
public Socket getSocket() {
return cliente;
}
public void setSocket(Socket socket) {
this.cliente = socket;
}
}

import java.io.PrintStream;
import javax.swing.JOptionPane;
public class Cliente {
Socket servidor = null;
try {
String mensagem = (String) JOptionPane.showInputDialog(null, "Escreva uma mensagem:",
"Mensagem do Cliente", JOptionPane.PLAIN_MESSAGE, null, null,
"escreva aqui");
System.out.println("[CLIENT] - Conectando no servidor");
servidor = new Socket("localhost", 1234);
System.out.println("[CLIENT] - Conexão com sucesso !!!");
PrintStream printStream = new PrintStream(servidor.getOutputStream());
printStream.println(mensagem);
System.out.println("[CLIENT] - Mensagem enviada: " + mensagem);
} finally {
try {
servidor.close();
} catch (IOException e) {}
}
}
}

Sockets
Detalhes:
• O cliente informa o endereço e a porta do servidor para efetuar a conexão.
• Nosso cliente envia uma informação através de uma caixa de dialogo.
• O servidor imprime a informação enviada pelo cliente.

Sinais
Detalhes:
• São eventos disparados dentro de um sistema operacional para indicar
alguma ação dentro de um processo.
• Efetua a comunicação desses eventos para um processo.
• Os sinais são eventos assíncronos.
• Um exemplo de sinal é quando uma aplicação é finalizada.

public class ShutdownHook {
Runtime.getRuntime().addShutdownHook(new Thread() {
@Override
public void run() {
System.out.println("Terminando o programa");
}
});
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
}
}
}

Resumo
• Comunicação entre processos é troca de informações entre programas.
• Essa comunicação pode ser:
• Arquivo compartilhado.
• Socket.
• Serialização é o processo de gravar as informações de uma classe em Java
em um arquivo.
• Deserialização é o processo de recuperar informações de um arquivo e
carrega-los em uma classe Java.

Obrigado !!!
ANHANGUERA – 2016.1

Programação Concorrente - Aula 05

Mais conteúdo relacionado

Mais procurados

Destaque

Semelhante a Programação Concorrente - Aula 05

Mais de thomasdacosta

Programação Concorrente - Aula 05