Redes, Threads e Marshalling

Prévia do material em texto

Redes, Threads e Marshalling 
1. Comunicação Entre Processos
2. Sockets Unix 
3. Sockets TCP/IP 
● Sockets TCP 
● Sockets UDP
Esses conceitos são fundamentais para entender como a comunicação entre processos e dispositivos funciona em sistemas distribuídos, e como a troca de dados é organizada e executada de forma eficiente.
obs: Um processo é uma instância de um programa em execução. Ele tem seu próprio espaço de memória, código, dados e estado de execução. Em sistemas operacionais modernos, vários processos podem ser executados simultaneamente (concorrência), mas eles não compartilham diretamente a memória entre si. Isso é feito para garantir segurança e integridade.
—---------------------------------------------------------------------------------
contextualização de distribuido:
Na programação distribuída, a ideia central é que uma aplicação ou sistema é dividida em múltiplas partes que são executadas em diferentes computadores, também chamados de nós ou máquinas. Cada um desses nós executa processos independentes, e esses processos não compartilham memória, mesmo que façam parte da mesma aplicação lógica.
Em sistemas distribuídos, estamos falando de vários processos ou instâncias de uma aplicação executados em máquinas diferentes, cada uma com seu próprio sistema operacional e memória. Esses processos não compartilham memória, mesmo que façam parte de uma mesma aplicação lógica. A comunicação entre eles acontece através de mensagens trocadas pela rede, seja por sockets, fila de mensagens ou outros mecanismos de IPC distribuído. O design e a implementação de um sistema distribuído envolvem uma série de desafios, como garantir consistência de dados, sincronização e tolerância a falhas, tudo isso devido ao ambiente físico separado em que os processos são executados.
Diferença entre Processos em um Sistema Local e em um Sistema Distribuído
Em um sistema local (um único computador), quando falamos de processos ou threads, eles podem compartilhar recursos, como a memória, o sistema de arquivos, ou mesmo a CPU, pois estão sob o controle do mesmo sistema operacional. Em contraste, em um sistema distribuído, os processos estão fisicamente separados. Eles estão sendo executados em máquinas diferentes, com seus próprios sistemas operacionais e memórias independentes.
Conceitos Centrais na Programação Distribuída
Aqui estão alguns pontos importantes para entender a dinâmica da programação distribuída:
1. Memória Não Compartilhada
Embora você possa ter várias instâncias de uma mesma aplicação (ou de seus componentes) rodando em diferentes máquinas, elas não compartilham a mesma memória. Cada máquina tem seu próprio espaço de memória, CPU, sistema de arquivos, etc.
Isso significa que, mesmo sendo a mesma aplicação distribuída, os processos ou threads que estão sendo executados não podem acessar diretamente a memória uns dos outros, porque estão em máquinas diferentes. Para trocar dados entre si, elas precisam usar técnicas de comunicação entre processos (IPC), como sockets, fila de mensagens, ou chamadas de procedimento remoto (RPC).
2. Comunicação via Rede
Em vez de compartilhar diretamente a memória, os processos em um sistema distribuído comunicam-se por meio de uma rede. Isso é feito usando protocolos como o TCP/IP ou UDP (através de sockets). Essas comunicações ocorrem por mensagens enviadas pela rede, e não por meio de ponteiros de memória ou variáveis compartilhadas.
Por exemplo, se uma parte da sua aplicação está em um servidor e a outra parte está em outro servidor em uma cidade diferente, eles precisarão se comunicar via rede — e não diretamente pela memória.
3. Coordenação e Sincronização
A coordenação entre processos em um sistema distribuído é muito mais complexa do que em um sistema local. Como os processos estão separados, a comunicação é mais lenta (por causa da latência da rede) e mais incerta (pacotes de dados podem ser perdidos ou atrasados).
Por isso, são necessários mecanismos adicionais para garantir:
· Consistência de dados: Já que cada nó tem sua própria memória, precisamos de métodos para garantir que todos os nós vejam os mesmos dados quando necessário.
· Tolerância a falhas: Se um dos nós falhar, a aplicação distribuída precisa continuar funcionando de alguma forma.
—------------------------------------------------------------------------------------
· IPC (comunicação entre processos)
Comunicação entre processos pode ocorrer localmente ou entre sistemas distribuídos e é fundamental para o funcionamento de sistemas modernos.
A Comunicação entre Processos (IPC - Inter-Process Communication) refere-se ao conjunto de mecanismos e técnicas que permitem que diferentes processos troquem informações entre si. Processos, por padrão, são isolados uns dos outros, ou seja, cada processo tem sua própria memória e não pode acessar diretamente a memória de outro processo. Para que eles troquem dados, precisam de meios de comunicação específicos, fornecidos pelo sistema operacional ou pela própria aplicação.
Comunicação entre processos é fundamental para permitir que aplicações complexas cooperem e compartilhem dados. Dependendo das necessidades de desempenho, segurança e arquitetura da aplicação, você pode escolher entre diferentes mecanismos de IPC, como memória compartilhada, pipes, filas de mensagens, semafóros e sockets. Cada técnica tem seus próprios benefícios e limitações, e o uso correto delas é essencial para o design eficiente de sistemas.
Cada processo tem sua própria memória, então o compartilhamento de dados entre eles requer uma estratégia especial. Existem várias técnicas para comunicação entre processos:
Memória Compartilhada: Dois ou mais processos compartilham uma região de memória onde podem ler e escrever. A vantagem é a alta velocidade, mas precisa de mecanismos de controle para evitar conflitos (concorrência).
Pipes e Named Pipes: Permitem a comunicação unidirecional ou bidirecional entre processos. São usados frequentemente para transferir dados entre processos pai e filho em um sistema.
Mensagens: O envio de mensagens (ou filas de mensagens) entre processos oferece um meio estruturado para comunicação, onde processos trocam mensagens por meio de um intermediário (como o sistema operacional).
Sockets: Sockets são uma das formas mais flexíveis de comunicação, permitindo que processos se comuniquem não apenas no mesmo sistema, mas também em sistemas distribuídos pela rede.(essencial para o próximo tópico)
Após a introdução do assunto ser feita, vamos para os ótpicos abordados no slide:
Resumo: 
A comunicação entre processos é fundamental em sistemas operacionais e redes, permitindo que diferentes processos troquem informações. Essa comunicação pode ser síncrona, onde as operações de envio e recebimento são bloqueantes e exigem a sincronização entre os processos, ou assíncrona, onde as mensagens são enviadas sem aguardar confirmação, permitindo que o remetente continue sua execução.
Para implementar essa comunicação, utilizamos sockets, que são interfaces que permitem a troca de dados entre processos, seja no mesmo sistema ou entre sistemas diferentes. Existem diferentes tipos de sockets, como os sockets Unix, que são usados para comunicação entre processos em sistemas Unix/Linux, e os sockets TCP/IP, que são utilizados na comunicação em redes.
Dentro dos sockets TCP/IP, existem duas categorias principais: sockets TCP, que oferecem uma comunicação orientada à conexão e garantem a entrega dos dados de forma sequencial e confiável, e sockets UDP, que proporcionam uma comunicação não orientada à conexão, priorizando a velocidade em vez da confiabilidade, mas sem garantir a entrega dos dados. Assim, a escolha entre comunicação síncrona ou assíncrona e o tipo de socket a ser utilizado depende dos requisitos específicos da aplicação e da natureza da troca de dados entre os processos.
Explicação mais detalhada:
A comunicação entre processos pode ser classificada como síncrona ou assíncrona 
1. Comunicação Síncrona
Na comunicação síncrona, o processo que enviauma mensagem aguarda a confirmação de recebimento antes de continuar sua execução. Isso significa que o remetente e o destinatário precisam estar prontos para se comunicar ao mesmo tempo. 
2. Comunicação Assíncrona
Na comunicação assíncrona, o processo que envia uma mensagem não espera uma confirmação imediata do destinatário e pode continuar sua execução sem bloqueio. 
Send e Receive: Operações básicas que definem a comunicação entre processos, utilizando filas para armazenar mensagens e podendo envolver sincronização.
Comunicação Síncrona: Operações de envio e recebimento bloqueantes, onde o remetente aguarda a confirmação de recebimento.
Comunicação Assíncrona: Operações de envio e recebimento não-bloqueantes, onde o remetente continua a execução sem esperar pela confirmação.
Threads: As operações bloqueantes podem ser realizadas em threads separadas, permitindo que o processo principal continue a execução.
Esses tópicos descrevem como os processos em um sistema se comunicam entre si, a diferença entre comunicação síncrona e assíncrona, e como essas operações podem ser implementadas eficientemente usando threads. 
1. Operações Básicas: Send e Receive
· Definição: Essas operações são os métodos fundamentais para enviar e receber mensagens entre processos.
· Destinos e Mensagens: Cada operação está relacionada a um destino (o processo receptor) e à mensagem que está sendo transmitida.
· Filas de Mensagens: As mensagens são gerenciadas em filas ou buffers, que armazenam temporariamente os dados.
· Sincronização: A comunicação pode requerer sincronização entre os processos para garantir que as mensagens sejam entregues corretamente.
2. Tipos de Comunicação: Síncrona e Assíncrona
Comunicação Síncrona
· Sincronização: As operações de envio (send) e recebimento (receive) são bloqueantes. O remetente aguarda até que a mensagem seja recebida pelo destinatário antes de continuar.
· Praticidade: É a forma mais comum de comunicação em sistemas, por ser mais simples de entender e implementar.
Comunicação Assíncrona
· Não-Bloqueante: O remetente envia a mensagem e continua a execução sem esperar pela confirmação de recebimento.
· Eficiência: Permite uma maior eficiência e responsividade, especialmente em sistemas onde as operações podem levar um tempo indeterminado.
3. Execução em Fluxos (Threads) Separados
· Uso de Threads: Mesmo com operações bloqueantes, as comunicações podem ser realizadas em threads separadas, permitindo que o processo principal continue sua execução paralelamente.
· Sobre sockets:
Sockets são ferramentas de software que permitem a comunicação entre processos, seja em uma única máquina ou em máquinas diferentes em uma rede. Eles fornecem um ponto de extremidade para o envio e recebimento de dados, funcionando como uma interface entre as aplicações e a pilha de protocolos de comunicação.
Soquetes são canais de comunicação que permitem processos não relacionados a troca de dados localmente e através de redes. Um único soquete é um ponto final de um canal de comunicação de duas vias.
Os sockets são fundamentais para a comunicação em rede, permitindo que diferentes aplicações se conectem e troquem dados de forma eficiente. Eles abstraem os detalhes complexos do transporte de dados, proporcionando uma interface simples para os desenvolvedores.
Representação do Processo
Um socket não é uma representação do processo em si, mas sim uma interface que permite que um processo se comunique com outro. Pense no socket como uma “porta” através da qual um processo pode enviar e receber informações. O socket serve como um identificador que liga um processo a um endereço de rede (IP e porta), permitindo que ele interaja com outros processos, seja na mesma máquina ou em máquinas diferentes.
Resumo
· Criação: Você cria um socket no seu código usando uma biblioteca.
· Configuração: O socket é associado a um endereço IP e porta.
· Conexão: No caso de TCP, você estabelece uma conexão com outro socket.
· Envio/Recepção: Os sockets permitem enviar e receber dados.
· Encerramento: Os sockets devem ser fechados quando não forem mais necessários.
Quando você cria e manipula um socket no código, está encapsulando uma série de operações complexas que facilitam a comunicação entre processos. Desde a inicialização até o envio e recebimento de dados, passando pela gestão de conexões e controle de erros, os sockets abstraem muitos detalhes técnicos, permitindo que você se concentre na lógica da aplicação sem precisar se preocupar com as complexidades da comunicação em rede.
Criação de Sockets
Para que a comunicação ocorra, é necessário que o processo remetente crie um socket e que o processo destinatário faça o mesmo. Cada socket funciona como um ponto de extremidade, e sua criação é um passo essencial para iniciar a troca de mensagens. Além disso, a comunicação é bidirecional, o que significa que o mesmo socket pode ser utilizado tanto para enviar quanto para receber mensagens. Isso simplifica o design das aplicações, pois a mesma estrutura pode ser utilizada para ambos os sentidos da comunicação.
obs:Uma comunicação não bidirecional se caracteriza pela ausência de troca de mensagens entre as partes. Um lado envia informações, enquanto o outro apenas recebe, sem a possibilidade de resposta
Modelo Cliente/Servidor
O uso de sockets está geralmente associado ao modelo cliente/servidor. Nesse modelo, um servidor escuta solicitações de clientes e responde a elas. No entanto, os papeis de cliente e servidor não são fixos. Um servidor pode também atuar como cliente ao se conectar a outros serviços. Isso proporciona flexibilidade na construção de sistemas distribuídos, onde diferentes partes do sistema podem se comunicar entre si de forma dinâmica.
Comunicação Local e Remota
Os sockets também possibilitam a comunicação entre processos na mesma máquina. Esse tipo de comunicação é frequentemente realizado através de Sockets Unix, que são otimizados para operações locais. Por outro lado, quando se trata de comunicação entre máquinas diferentes, são utilizados Sockets TCP e Sockets UDP. Esses protocolos são essenciais para a comunicação em redes de computadores, incluindo a Internet e redes privadas.
· Sockets TCP: Proporcionam uma conexão orientada, garantindo que os dados sejam entregues de forma confiável e na ordem correta. Isso os torna ideais para aplicações onde a integridade dos dados é crucial, como transferências de arquivos ou comunicação de aplicativos web.
· Sockets UDP: Oferecem uma comunicação sem conexão, que não garante a entrega ou a ordem dos pacotes. Isso pode ser vantajoso em situações onde a velocidade é mais importante do que a precisão, como em transmissões de vídeo ao vivo ou jogos online, onde perder alguns pacotes pode não impactar significativamente a experiência do usuário.
Pontos do slide sobre sockets unix e tcp/udp
· Sockets unix: para comunicação entre processos na mesma máquina
Os Sockets Unix são uma forma de comunicação entre processos que ocorre dentro do mesmo sistema operacional, Essa comunicação é feita através de um arquivo especial que funciona como um ponto de acesso (ou "endereço") para que os processos possam trocar informações.
Utiliza as classes Java SocketChannel e ServerSocketChannel
São endereçados por meio de arquivos de sistema passando o Path do arquivo, que será o endereço do socket
A conexão é limitada em apenas um host físico
Podem ser usados para conectar com um banco de dados, como o MongoDB e o PostgreSQL, apresentam configuração padrão
pronta para uso
obs: Quando comparado com os Sockets TCP/IP, os Sockets Unix apresentam
tempo de configuração mais rápida e maior saída de dados, Além de que não apresenta risco de segurança, por não realizar/aceitar conexões remotas.
Multicast e Marshalling
Multicast:
Multicast é um método eficiente de comunicação em rede que permite o envio de uma única mensagem para múltiplos destinatários simultaneamente. Esse método é amplamente utilizado em aplicações que exigem a distribuição de dados a um grupo específicode receptores, como streaming de vídeo, conferências em áudio, ou atualizações em tempo real.
um processo envia dados/msg para os processos do grupo
Baseado em datagram UDP não oferece garantia de entrega e ordenação de pacote
grupos identificados por IP e porta
Operações para gerenciar grupo: joinGroup p entrar em um e LeaveGroup p sair
image2.png
image1.png
image3.png