Fundamentos de Sistemas Operativos - 2024-2025

Um mecanismo de comunicação entre processos que permite o compartilhamento direto de dados na memória.

Uma classe que permite comunicação entre processos JAVA através de memória partilhada.

Um arquivo que é usado para armazenar os dados compartilhados entre processos.

Um canal que conecta o conteúdo de um arquivo ao buffer de memória compartilhada.

Uma região específica de memória que permite a leitura e escrita de dados compartilhados.

Uma região de memória que armazena dados compartilhados.

O tamanho máximo em bytes que o buffer de memória compartilhada pode armazenar.

Um método que permite a comunicação entre processos utilizando memória partilhada.

Permite a comunicação entre processos na mesma máquina, permitindo que compartilhem dados e recursos.

Um processo que pode acessar e modificar dados na memória compartilhada juntamente com outros processos.

Um programa fundamental que administra os recursos de um computador, como o processador, memória e dispositivos de entrada e saída. Permite aos usuários interagir com o hardware de forma mais fácil.

Os Sistemas Operativos Mono-Usuário eram utilizados em computadores pessoais antigos. Exemplos: CPM e MS-DOS.

Linguagem de baixo nível compreendida pelo processador. É uma sequência de instruções. Cada instrução manipula os dados diretamente.

Os Sistemas Operativos facilitam o uso do hardware, criando uma abstração chamada máquina virtual.

Refere-se à camada de software que torna o hardware acessível aos usuários. Cria uma interface de usuário amigável, gerenciando o acesso aos recursos.

O objetivo principal do sistema operativo é facilitar e maximizar o uso dos recursos do hardware do computador.

Modelos modernos que permitem que múltiplos usuários acessem e utilizem o mesmo computador ao mesmo tempo, como Windows, Linux e macOS.

Sistemas operativos projetados para serem usados por vários usuários simultaneamente, permitindo que diferentes processos compartilhem recursos do sistema, como a CPU e memória.

Um sistema operacional proprietário que deu origem a uma série de evoluções e versões, incluindo Windows 95, 98, XP, Vista, 7, 8 e 10.

Camadas funcionais, que representam módulos de gerenciamento de recursos do sistema, cada camada é responsável pela gestão eficiente de um recurso físico da máquina hardware.

Um processo pode ser dividido em múltiplas tarefas. Cada tarefa é uma atividade executada dentro do processo, possuindo código e dados independentes das outras tarefas. Uma tarefa em Java é implementada como uma classe que deriva da classe Thread, herdando seus métodos.

Uma abordagem estrutural que organiza o sistema operacional em módulos independentes, permitindo que cada módulo seja desenvolvido, testado e depurado separadamente.

A classe Thread é a base para criar e gerenciar tarefas em Java. Ela está disponível na biblioteca java.lang.Thread e implementa a interface Runnable. Ao estender a classe Thread, sua classe se torna uma tarefa que pode ser executada dentro de um processo.

Gerenciamento de Processos e Tarefas, uma parte fundamental do sistema operacional que é responsável por controlar a execução de processos e tarefas, garantindo que seus recursos sejam alocados e gerenciados de forma eficiente.

Sincronização, um mecanismo que garante que os processos compartilhem recursos de forma segura, evitando conflitos e garantindo a consistência dos dados.

Existem duas formas de definir uma classe do tipo Thread em Java: herdar diretamente da classe Thread ou implementar a interface Runnable. Ambas permitem criar tarefas, mas a primeira oferece métodos para gerenciamento de threads diretamente na classe da tarefa.

Gerenciamento de Memória, uma camada crucial que aloca e gerencia a memória disponível no sistema, garantindo que os processos tenham acesso à quantidade de memória que precisam para funcionar corretamente.

O método start() da classe Thread inicia a execução da tarefa, permitindo que ela seja executada em paralelo com o código principal do processo. Ao usar start(), você chama o método run() da classe Thread, que é a base da execução da tarefa.

O método run() é o coração da classe Thread. Ele define as ações que a tarefa realiza. Quando o método start() é chamado, o método run() da classe Thread é executado como uma thread separada.

Comunicação, um mecanismo que permite que diferentes processos se comuniquem entre si e com dispositivos externos, facilitando a troca de informações.

Gerenciamento de Ficheiros, um componente que organiza e administra os arquivos do sistema, garantindo que a informação seja armazenada e recuperada de forma segura e eficiente.

A gestão de processos é o mecanismo pelo qual o sistema operativo permite que múltiplos programas (processos) partilhem os recursos físicos da máquina, permitindo que sejam executados em simultâneo.

Um processo pode passar por diferentes estados de funcionamento, como inicialização (criado, mas ainda não em execução), pronto (esperando por sua vez para executar), execução (a executar), espera (aguardando um evento) e terminado (execução concluída).

A inicialização é a primeira fase de um processo onde o programa é criado, mas ainda precisa obter os recursos necessários para começar a executar.

Um processo está em estado pronto quando está pronto para começar a executar, mas está esperando sua vez na fila de espera para obter o CPU.

Um processo em estado de execução está a usar o CPU e a executar tarefas específicas.

Um processo em estado de espera está a aguardar que um evento ocorra, como a entrada do utilizador, dados de uma rede ou a conclusão de uma operação I/O.

Um processo está em estado terminado quando a execução é concluída e os recursos do sistema são libertados.

Em Java, pode-se criar um processo utilizando a classe ProcessBuilder, um objeto que recebe como parâmetro o nome do programa e path.

O método start() da classe ProcessBuilder é usado para iniciar a execução do processo, ativando o programa especificado.

O método DirAll é chamado com um nome de diretoria. Se o nome for uma diretoria, o método lista todos os arquivos dentro da diretoria e os arquivos dentro das subdiretorias, referindo as subdiretorias.

O método DirAll recebe o caminho para uma diretoria como parâmetro.

O método DirAll lista os arquivos dentro da diretoria e as subdiretorias, fornecendo o caminho completo de cada arquivo.

O método Dir recebe um nome, geralmente um nome de arquivo. Se o nome for uma diretoria, o método mostra a lista de arquivos dentro dessa diretoria.

O método Dir usa File.isDirectory() para verificar se o caminho fornecido é uma diretoria. Se for, o método mostra os arquivos dentro da diretoria.

O método Dir usa File.listFiles() para obter uma lista de arquivos dentro da diretoria. Em seguida, itera pela lista e mostra o nome de cada arquivo.

O método Dir usa File.canRead() para verificar se o arquivo pode ser lido. Se não, o método mostra uma mensagem indicando que o arquivo não pode ser lido.

Um autómato não bloqueante com estado terminal difere de um autómato não bloqueante sem estado terminal, pois retorna uma informação sobre a conclusão da atividade através de uma função.

No exemplo do diagrama de atividades com 2 atividades completamente ligadas, o código retorna true quando a atividade final é concluída e false caso contrário.

O robot LEGO NXT Mindstorms tem uma estrutura modelar com duas rodas de tração independentes na frente e uma roda livre atrás.

O robot LEGO NXT Mindstorms pode suportar até 4 sensores (por exemplo, de distância, cor, som) e 3 atuadores, como motores.

O robot LEGO NXT Mindstorms pode ser ligado a um computador através de uma ligação USB ou Bluetooth, permitindo programar e controlar suas ações.

Um ponto de sincronização entre dois ou mais fluxos concorrentes de ações, onde a execução de uma sequência depende da conclusão de todas as outras.

Mecanismo para modelar a comunicação e sincronização entre tarefas diferentes dentro de uma aplicação. Representam a colaboração e interdependência.

Processo de executar uma tarefa. A tarefa é iniciada para executar em paralelo com o código principal.

O autómato bloqueante é um tipo de máquina de estados finitos que é usado para implementar diagramas de atividades. Ele possui um número finito de estados e transições entre esses estados. A estrutura do autómato é definida pelas ações a serem realizadas em cada estado (atividades) e pelas condições que determinam a transição de um estado para outro.

Cada estado no autómato bloqueante representa uma atividade do diagrama de atividades. Cada atividade possui um conjunto de ações a serem executadas quando o autómato estiver nesse estado.

As transições no autómato bloqueante são definidas por condições que devem ser satisfeitas para que ocorra a mudança de estado. A condição para cada transição representa um evento ou condição que desencadeia a mudança do estado atual para outro.

Ações de transição são ações executadas quando ocorre uma transição de um estado para outro. Estas ações podem ser usadas para atualizar o estado do sistema, enviar mensagens ou executar outras tarefas.

O estado inicial do autómato bloqueante, onde o processo começa a ser executado.

O conjunto de estados finais do autómato bloqueante, onde o processo termina sua execução.

O ciclo de vida do autómato bloqueante é definido pelo loop infinito, que continua até que o processo seja interrompido. O loop é responsável por verificar as condições de transição e executar as ações correspondentes.

A estrutura genérica do autómato bloqueante é uma estrutura que descreve a lógica do sistema. Ela define a estrutura básica do autómato e é reutilizável em diferentes diagramas de atividades.

As ações a serem realizadas em cada estado são chamadas de atividades. As atividades são parte fundamental do processo definido pelo diagrama de atividades.

Condições que definem as transições entre os estados são usadas para determinar quando as atividades devem mudar. As transições são disparadas quando as condições forem satisfeitas.

Os diagramas de atividade da UML (Unified Modelling Language) são ferramentas poderosas para modelar o comportamento de sistemas, incluindo aplicações multi-processo. Eles permitem visualizar o fluxo de atividades, transições entre estados e interações entre diferentes componentes do sistema.

Uma aplicação multi-processo ou multi-tarefa consiste em vários processos ou tarefas que trabalham em conjunto para realizar uma função específica.

Swimlanes são um elemento de diagramas UML que representam diferentes processos ou partes de um sistema, separando visualmente as atividades que cada um executa.

Os diagramas de atividade podem ser adaptados para modelar cada processo dentro de uma aplicação multi-processo. Cada processo é representado como um conjunto de atividades conectadas por transições, que representam o fluxo de execução do processo.

As actividades de ação representam uma operação individual dentro de um diagrama de atividade, como uma operação matemática, uma requisição de dados ou uma atualização de um estado.

As atividades de subatividade no diagrama de atividade representam um conjunto de ações ou operações dentro de um processo, que podem até ser modeladas por outros diagramas de atividade.

As transições entre atividades em um diagrama de atividade podem ser condicionais ou incondicionais, dependendo de uma condição específica ou de um evento que precisa ocorrer para a próxima atividade acontecer.

As atividades podem representar operações, métodos, transferência de objetos entre processos e especificação dos objetos a transferir. Isso permite modelar de forma mais rica e precisa a interação entre os processos.

A linguagem gráfica standard para modelar aplicações multi-processo é a UML, o que facilita a comunicação entre desenvolvedores e a colaboração na criação de soluções para aplicações complexas.

A memória partilhada em JAVA é uma memória mapeada de um ficheiro que tem de ser conhecido dos vários processos através do path e nome do ficheiro.

A classe canalComunicacao é uma classe que permite a comunicação entre processos JAVA através de memória partilhada. Permite partilhar dados entre diferentes processos.

O FileChannel é um canal que conecta o conteúdo de um ficheiro ao buffer de memória compartilhada. Permite o acesso direto aos bytes do ficheiro.

O MappedByteBuffer é uma região específica de memória que permite a leitura e escrita de dados compartilhados. É como uma janela para ver e editar os dados.

O BUFFER_MAX é a dimensão máxima em bytes que o buffer de memória compartilhada pode armazenar. Controla a quantidade de dados que podem ser partilhados.

O File é um objeto que representa um ficheiro no sistema. Define o caminho e nome do ficheiro.

O buffer é uma região de memória que armazena dados compartilhados. É como um recipiente para armazenar os dados antes de serem partilhados.

O canal é um objeto que permite a comunicação entre o buffer e o File. Ele permite que a memória compartilhada seja sincronizada com o ficheiro.

O construtor da classe canalComunicacao é usado para inicializar os membros da classe, incluindo o ficheiro, FileChannel e MappedByteBuffer. É como a primeira etapa para configurar a comunicação.

A comunicação por memória partilhada é um método que permite a comunicação entre processos utilizando memória partilhada. É como uma área comum onde todos os processos podem trocar informações.

Um processo é uma unidade básica de execução em um sistema operacional. Ele representa um programa em execução, que possui seu próprio espaço de endereço e recursos, como memória e arquivos.

Uma tarefa é um bloco de trabalho dentro de um processo, geralmente representada por uma função (ou uma série de funções) que manipula dados do processo.

Um processo pode ser desenhado para conter múltiplas tarefas. Cada tarefa é implementada como uma classe Java que deriva da classe Thread.

A máquina virtual Java (JVM) permite a execução de múltiplas tarefas ('Threads') dentro de um processo. Isso permite que um programa execute diferentes partes de sua lógica simultaneamente.

A classe Thread é acessada através da biblioteca java.lang.Thread e tem a declaração: public class Thread extends Object implements Runnable

Existem duas maneiras de definir uma classe do tipo Thread: 1. Herdando diretamente da classe Thread 2. Implementando a interface Runnable.

O método start() inicia a execução da tarefa, permitindo que ela seja executada em paralelo com o código principal do processo.

O método run() é o coração da classe Thread, definindo as ações que a tarefa realiza quando ela é executada.

A JVM permite que múltiplas tarefas compartilhem os recursos do processo-pai, o que requer mecanismos de sincronização para garantir que as tarefas não interfiram umas com as outras ao acessar dados compartilhados.

A memória compartilhada é um mecanismo de comunicação entre processos e tarefas onde os processos podem acessar e modificar diretamente os dados na memória.

Em Java, o processo pode ser criado utilizando a classe ProcessBuilder. O nome do processo e o caminho para o executável são parâmetros de entrada para a classe. A criação do processo ocorre através da instanciação da classe ProcessBuilder e chamada do método start(). Exemplo:

ProcessBuilder pb = new ProcessBuilder("nomeProcesso");
Process p = pb.start();   // inicia o processo

Um processo pode estar em diferentes estados dependendo do momento. O diagrama de estados mostra as diferentes fases do ciclo de vida de um processo. As transições entre estados são representadas por setas que indicam os eventos que causam a mudança de estado.

A comunicação entre processos permite que diferentes processos compartilhem dados, recursos e controlem a sua execução. Em Java, a comunicação pode ser realizada através de vários mecanismos, como memória compartilhada ou mensagens.

Em Java, um processo pode ser dividido em múltiplas tarefas, chamadas de threads. Cada thread pode executar uma tarefa específica dentro do processo, tornando-o mais eficiente.

A sincronização entre threads é crucial para garantir a consistência e integridade dos dados. Por exemplo, em um sistema de banco, várias threads podem acessar a mesma conta bancária. A sincronização garante que as operações sejam executadas em ordem e de forma segura.

Uma operação que decrementa o valor de um semáforo quando este é maior do que zero.

Uma situação em que dois ou mais processos ficam bloqueados indefinidamente, esperando que um recurso seja libertado pelo outro.

Um objeto que controla o acesso concorrente a recursos em um sistema multi-processo.

Uma operação que permite a um processo liberar um recurso, sinalizando que ele está disponível para outros processos.

A função Swimlanes em um diagrama de atividade, representada por faixas de natação, serve para destacar visualmente os processos ou componentes do sistema que desempenham diferentes tarefas. Ela ajuda a visualizar a colaboração entre processos e a divisão de responsabilidades dentro do sistema.

A comunicação entre processos em Java pode ser realizada através de Sockets por TCP (Transfer Control Protocol), que fornece um mecanismo confiável e orientado à conexão para troca de dados entre processos em uma rede.

A comunicação entre processos em Java pode ser realizada através de Sockets por UDP (User Datagram Protocol), que oferece um protocolo leve e sem conexão para troca de dados entre processos em uma rede. É ideal para aplicações com baixa latência e onde a confiabilidade não é crítica.

As transições no autómato bloqueante são representadas como setas no diagrama de atividade, indicando a mudança de um estado para outro, dependendo de uma condição específica. Essas transições definem o fluxo de trabalho e determinam como o processo progride de uma etapa para a próxima.