Celso luis Samussone

Elton Alexandre Novela

Emanuel Rodrigues Tourais

Sistemas Operativos
Temas:
Sistemas Monolíticos
Sistemas em camadas
Sistemas Micronúcleos
Máquinas virtuais

Faculdade de Engenharias e Tecnologias

Licenciatura em Informática
2 Ano

Universidade Pedagógica.
Maputo
Abril, 2023
 Celso luis Samussone
Elton Alexandre Novela
Emanuel Rodrigues Tourais

Sistemas Operativos
Temas:

Sistemas Monolíticos
Sistemas em camadas
Sistemas Micronúcleos
Máquinas virtuais

Trabalho de Sistemas Operativos com o tema:

Sistemas monolíticos
Sistemas em camadas
Sistemas micronúcleo
Máquinas virtuais. A ser entregue para efeitos
de avaliação pelo Mestre Aurélio Armando
Pires Ribeiro

Universidade Pedagógica.
Maputo
Abril, 2023
Índice
Introdução. .............................................................................................................................................. 4
Objectivo geral. ....................................................................................................................................... 4
Objectivo específico ................................................................................................................................ 4
Sistema operacional monolítico. .............................................................................................................. 5
Características dos sistemas monolíticos. ............................................................................................. 5
Núcleo monolítico. .............................................................................................................................. 5
Aplicações monolíticas. ....................................................................................................................... 5
Vantagens............................................................................................................................................ 6
Desvantagens ...................................................................................................................................... 6
Exemplos ............................................................................................................................................ 6
Sistema Operacional em Camadas. .......................................................................................................... 7
Regras de implementação das camadas ................................................................................................ 8
Vantagens dos sistemas em 3 camadas. ................................................................................................ 8
Desvantagens ...................................................................................................................................... 8
Exemplo .............................................................................................................................................. 8
Sistemas Micronúcleo.............................................................................................................................. 8
Vantagens............................................................................................................................................ 9
Desvantagens ...................................................................................................................................... 9
Exemplo .............................................................................................................................................. 9
Máquinas virtuais. ................................................................................................................................. 10
Historia. ............................................................................................................................................ 10
Definição........................................................................................................................................... 10
Funcionamento. ................................................................................................................................. 11
Uso por teste...................................................................................................................................... 11
Classificação das máquinas virtuais ................................................................................................... 11
Tipos de máquinas virtuais. ............................................................................................................... 12
Vantagens.......................................................................................................................................... 12
Desvantagens..................................................................................................................................... 13
Segurança. ......................................................................................................................................... 13
Tipos ................................................................................................................................................. 13
Conclusão ............................................................................................................................................. 14
Referencias Bibliográficas ..................................................................................................................... 15
Introdução.
Um sistema operativo é um conjunto de programas de um computador que realizam uma gestão
eficaz de seus recursos. Um sistema operativo tem como objectivo principal controlar a execução
de programas. Permitir o uso eficiente dos recursos do computador, atuar como intermediário
entre o hardware e o os programas de aplicação, proporcionar comodidade ao utilizador do
computador.
O presente trabalho tem como objetivo, abordar os conceitos de Sistema monolítico,
micronúcleo, em camadas e máquinas virtuais. Onde traremos o historial de surgimento de cada
sistema, as suas vantagens, desvantagens, aplicações e tipos.

Objetivo geral.
- Conhecer o sistema monolítico, micronúcleo, em camadas e máquinas virtuais.

Objetivo específico
- Analisar a aplicação de cada tipo de sistema citado acima;
- Compreender as desvantagens e vantagens do uso ou implementação dos sistemas citados.
Sistema operacional monolítico.
É um termo usado para designar o modelo de sistema operacional que é codificado por via de uma
coleção de procedimentos, onde é permitido a qualquer um deles em qualquer parte do programa
interagir livremente com outro procedimento.
A arquitetura monolítica contém vários procedimentos que são compilados separadamente e
depois linkados, formando um grande e único programa executável, onde todos os módulos podem
interagir livremente. É a arquitetura de sistema operacional mais antiga e mais comum conhecida.
Ela se caracteriza pelo fato de cada componente do sistema operacional ser contido no núcleo
(kernel) e pode comunicar-se diretamente com qualquer outro componente (utilizando chamadas
à função), justamente por isso o núcleo normalmente tem acesso irrestrito ao sistema de
computador.
No núcleo/kernel monolítico, o sistema operacional é escrito como se fosse um conjunto de rotinas,
de forma que cada rotina pode chamar, ou ainda, se comunicar, com outra rotina, sempre que for
necessário. Esse sistema possui um núcleo grande e complexo que engloba todos os serviços.
Todos os componentes funcionais do kernel têm acesso a todas as suas estruturas de dados e rotinas
internas, com isso, um erro em uma rotina pode comprometer todo o núcleo.
O sistema monolítico é estruturado em um único arquivo binário, em apenas um processo que
executa inteiramente em modo protegido
Características dos sistemas monolíticos.
 A construção é baseada em módulos, que são unidos através de Linkers (a partir de vários
módulos é gerado um executável).
 Boa definição de parâmetros de ligação entre as diferentes rotinas existentes, aumenta o
desempenho, mas o sistema pode parar devido a algum erro ocasionado por uma dessas
rotinas.
 Geralmente são feitos à medida, pelo que são eficientes e rápidos na execução e na gestão.
 Não são muito flexíveis a diferentes ambientes para além dos quais foram criados.
 Os primeiros Sistemas Operacionais foram desenvolvidos baseando-se neste modelo, o
que tornava seu desenvolvimento e manutenção muito difíceis.
Núcleo monolítico.
 Núcleos monolíticos normalmente são eficientes pois poucas chamadas precisam ir da área
do usuário para a área do núcleo.
 Todos os códigos de sistemas operacionais em núcleos monolíticos operam com acesso
irrestrito ao software e hardware do computador, portanto esses sistemas são
particularmente suscetíveis a danos provocados por códigos sujeitos a erros.
Aplicações monolíticas.
- Um aplicativo monolítico é um aplicativo de software de camada única no qual a interface do
usuário e o código de acesso são dados e combinados em um único programa a partir de uma única
plataforma.
- É autônomo e independente de outros aplicativos de computação.
- Um aplicativo monolítico descreve uma aplicação de software que é projetada sem modularidade.
- A modularidade é desejável, em geral, pois suporta a reutilização de partes da lógica da aplicação
e também a manutenção por reparo ou substituição de partes da aplicação sem a necessidade de
substituição em atacado.
Vantagens
 A grande vantagem de sistemas operacionais monolíticos é o desempenho, já que a forte
integração interna de seus componentes lhe permite que detalhes de baixo nível do
hardware sejam efetivamente explorados.
 A arquitetura possui intercomunicação direta e isso favorece no tempo de resposta do
sistema operacional.
 A interação direta entre os componentes torna o sistema mais compacto.
 Os componentes do núcleo pode acessar os demais sem qualquer tipo impedimento.
Desvantagens
 O sistema pode parar em função de um erro;
 As interfaces e os níveis de funcionalidade não são bem separados, nem estão unificados.
O excesso de liberdade torna o sistema vulnerável;
 Dificuldade em executar alterações no próprio núcleo, pois as dependências e pontos de
interação dos componentes podem não ser evidentes.
 É difícil identificar a origem de um problema ou erro, pois seus componentes estão todos
no mesmo lugar.
 Se um componente do núcleo apresentar um erro, esse problema pode se alastrar
rapidamente e levar o sistema ao colapso.
 Pequenas alterações na estrutura de dados de um componente, se acessados diretamente,
podem ter um impacto inesperado em outros componentes.
Exemplos
1. Os UNIX-likes (como Linux, Solaris, AIX, HP-UX, BSDs e seus derivados);
2. Microsoft MS-DOS e Windows 9x;
3. Apple Mac OS nas versões abaixo do 8.6.
4. Atualmente, apenas sistemas operacionais embutidos usam essa arquitetura, devido às
limitações do hardware sobre o qual executam
Sistema Operacional em Camadas.
O Sistema Operacional em Camadas é um termo oriundo dos estudos referentes a sistemas
operacionais, que designa os modelos de sistemas operacionais montados sobre uma hierarquia de
camadas.
O sistema operacional é organizado em camadas construídas uma sobre a outra. O primeiro sistema
construído dessa maneira foi o sistema criado no Technische Hogeschool Eindhoven, na Holanda,
por E. W. Dijkstra (1968) e seus alunos. O sistema THE era um sistema de lote simples para um
computador holandês, o Electrologica X8, que tinha 32K de palavras de 27 bits (bits eram caros
naquela época).
O sistema tinha seis camadas:

 A camada 0 (zero) lidava com a alocação do processador, alternando entre processos quando
ocorriam interrupções ou quando os temporizadores expiravam. Acima da camada 0 (zero), o
sistema consistia em processos sequenciais, cada um dos quais podia ser programado sem ser
necessário preocupar-se com o fato de que múltiplos processos estavam executando em um
único processador. Em outras palavras, a camada 0 (zero) proporcionava a multiprogramação
básica da CPU.
 A camada 1 fazia o gerenciamento da memória. Ela alocava espaço para os processos da
memória principal e em um tambor (Antigo meio magnético de armazenamento de dados) com
512K de palavras utilizado para armazenar partes do processo (páginas) para os quais não
havia lugar na memória principal. Acima da camada 1, os processos não tinha que se preocupar
com o fato de eles estarem em memória ou no tambor, o software da camada 1 cuidava de
assegurar que as páginas fossem levadas para a memória sempre que fossem necessárias.
 Já a camada 2 fazia a comunicação entre o console do operador e cada processo.
 A camada 3 gerenciava dispositivos de entrada e saída.
 A camada 4 localizavam-se os programas de usuários.
 A camada 5 era o usuário.
No entanto, a maioria dos sistemas de uso geral usa apenas duas camadas, mesmo que o hardware
em que são executados forneça mais modos de CPU do que isso. Por exemplo, o Windows 7 e
o Windows Server 2008 (e seus predecessores) usam apenas duas camadas, com o camada 0
correspondendo ao modo do núcleo e a camada 3 ao modo do usuário, porque as versões anteriores
do Windows eram executadas em processadores que suportavam apenas dois níveis de proteção.
Muitas arquiteturas modernas de CPU (incluindo a popular arquitetura Intel x86) incluem alguma
forma de proteção em camada, embora o sistema operacional Windows NT, como o Unix, não
utilize totalmente esse recurso. O OS/2 o fez até certo ponto, usando três camadas: camada 0 para
o código do núcleo e drivers de dispositivo, camada 2 para código privilegiado (programas de
usuário com permissões de acesso de E/S) e camada 3 para código não privilegiado (quase todos
os programas de usuário). No DOS, o núcleo, os drivers e os aplicativos normalmente são
executados na camada 3 (no entanto, isso é exclusivo para o caso em que drivers de modo protegido
e/ou extensores DOS são usados; como um sistema operacional de modo real, o sistema funciona
efetivamente sem proteção), enquanto gerenciadores de memória 386, como o EMM386, são
executados na camada 0.
Regras de implementação das camadas
1. A camada mais externa deve ser a camada de interface do usuário.
2. A camada mais interna deve ser a camada de hardware.
3. Uma determinada camada pode acessar todas as camadas presentes abaixo dela, mas não
pode acessar as camadas presentes acima dela. Ou seja, a camada n1 pode acessar as
camadas n2 a 0, mas não pode acessar a enésima camada.
Vantagens dos sistemas em 3 camadas.
1. Modularidade – este tipo de design promove a modularidade, pois cada camada realiza
apenas as tarefas que esta programada para realizar.
2. Depuração fácil – Como as camadas são discretas, é muito fácil depurara.
3. Fácil atualização – Uma atualização feita numa camada específica, não afetara as outras
camadas.
4. Sem acesso direto ao hardware – A camada hardware é acamada mais interna presente
no design. Assim, um usuário pode usar os serviços de hardware, mas não pode modifica -
los ou acessa-los diretamente, ao contrário do sistema simples em que o usuário tinha
acesso direto ao hardware.
5. Abstração – Cada camada esta realiza funções específicas, portanto, as funções e
implementações das outras camadas são abstratas a ele.
Desvantagens
1. Implementação complexa e cuidadosa – Uma vez qua uma camada pode acessar os
serviços das camadas abaixo dela, o arranjo das camadas deve ser feito com muito cuidado.
Assim quando mior for a modularidade mais complexa fica a implementação.
2. Lentidão na execução – Se uma camada deseja interagir com outra camada, ela envia uma
solicitação que deve viajar por todas camadas presentes entre as duas camadas em
interação. Assim aumenta o tempo de resposta, ao contrário do sistema monolítico, que é
mais rápido. Assim um aumento no número de camadas pode levar a um design muito
ineficiente.
Exemplo: Windows 7, Windows server, Windows NT, Unix, OS/2

Sistemas Micronúcleo.
Micronúcleo, ou microkernel, é uma arquitetura de núcleo (kernel) de um sistema operativo cujas
funcionalidades são quase todas executadas fora do núcleo, em oposição a um núcleo monolítico.
Os processos se comunicam com um núcleo mínimo, usando o mínimo possível o "espaço do
sistema" (kernel space). Neste local os aplicativos tem acesso a todas as instruções e a todo o
hardware e deixando o máximo de recursos rodando no "espaço do usuário" (user-space) em que
o software tem algumas restrições, não podendo acessar algumas hardwares, nem tem acesso a
todas as instruções).
Basicamente o Microkernel executa a maioria dos processos fora do kernel, ele carrega o mínimo
de processos possíveis no kernel space. O restante dos módulos são executados como processos
de usuário comum para o sistema.[1]
Um dos principais benefícios de utilizar a arquitetura dessa maneira, com divisão de tarefas entre
módulos, é uma menor preocupação com os erros, já que sistemas operacionais são muito sujeitos
a eles. Isso não quer dizer que erros não vão acontecer, porém, erros que provavelmente causariam
uma falha e derrubariam todo o sistema, agora irão apenas causar uma falha naquele módulo em
específico, trazendo alta confiabilidade.
Um bom exemplo de aplicação dessa arquitetura é o MINIX 3, que utilizou muito da modularidade
no seu sistema operacional. O seu micronúcleo tem cerca de 12000 linhas em C e 1400 linhas
de assembly para funções de nível muito baixo, como gerenciamento de interrupções e processos
de chaveamento. O código C gerência os processos e controla a comunicação entre eles, além de
permitir as chamadas para o núcleo, permitindo o sistema operacional funcionar. O driver de
dispositivo para o relógio também fica no núcleo, porque o escalonador interage proximamente
com ele. Os demais drivers do dispositivo operam como processos do usuário.
Além do núcleo, o sistema é estruturado em mais três camadas de processos, todas essas camadas
executando em modo de usuário. A camada inferior é responsável pelos drivers de dispositivos.
Como essa camada executa em modo usuário, ela não tem permissão para acessar fisicamente e
emitir comandos de E/S. Ao invés disso, é necessário construir uma estrutura com as informações
das portas que irão ser utilizadas e gerar uma chamada ao núcleo. Isso permite que o núcleo
verifique oque o driver está lendo ou escrevendo, não deixando que, por exemplo, um dispositivo
defeituoso escreva acidentalmente no disco.
Acima dos drivers está a camada que contém os servidores. Essa camada faz a maior parte do
trabalho do sistema operacional, já que gerência operações importantes do mesmo, como
gerenciamento de arquivos ou gerenciamento de processos, por exemplo. Os programas de usuário
enviam requisições aos servidores do que for necessário para o funcionamento do mesmo. Acima
dessa camada estão os programas de usuário, que utiliza chamadas nas demais camadas para
funcionar corretamente.
Uma estratégia interessante ligada ao núcleo minimalista é utilizar processos de modo usuário para
atribuir prioridades aos processos, desacoplando essa função do núcleo e reduzindo-o

Vantagens
Os sistemas micronúcleos são mais estáveis e permitem trabalhar com módulos.
Desvantagens
Os sistemas micronúcleos tem um baixo desempenho, comparado a outros tipos de sistema.

Exemplos de sistemas Micronúcleos.

Hurd.
MINIX
QNX
L4
Máquinas virtuais.
Na ciência da computação, máquina virtual consiste em um software de ambiente computacional
que executa programas como um computador real, também chamado de processo de virtualização.
Uma máquina virtual (Virtual Machine – VM) pode ser definida como “uma duplicata eficiente e
isolada de uma máquina real”. A IBM define uma máquina virtual como uma cópia isolada de um
sistema físico, e esta cópia está totalmente protegida.
Máquinas virtuais são extremamente úteis no dia a dia, pois permitem ao usuário rodar outros
sistemas operacionais dentro de uma única máquina física, tendo acesso a outros software
existentes que podem ser instalados dentro da própria máquina virtual.

Historia.
VM ou VM/CMS, do inglês Virtual Machine/Conversational Monitor System é um sistema
operativo que permite a vários utilizadores trabalharem ao mesmo tempo como se estivessem a
utilizar sozinhos o computador. O sistema foi empregue na IBM mainframes System/360,
donde VM/360, em 1964 - História do Mainframe [2].
IBM 704
O sistema VM é usado nos mainframes - computadores de grande capacidade capazes de oferecer
serviços de processamento a milhares de usuários através de milhares de terminais conectados
diretamente ou através de uma rede. O sistema operava unicamente em modo batch (arquivo de
lote).
O programa de controle (CP) gerencia o computador e efetua todas as operações necessárias de tal
forma que cada máquina virtual reaja e trabalhe como um computador pessoal. O utilizador tinha
em frente de si unicamente: um écran, um teclado, e a caixa de ligação com mainframe.

Definição
O termo máquina virtual foi descrito na década de 1960 utilizando um termo de sistema
operacional: uma abstração de software que enxerga um sistema físico (máquina real). Com o
passar dos anos, o termo englobou um grande número de abstrações – por exemplo, Java Virtual
Machine – JVM que não virtualiza um sistema real.
Ao invés de ser uma máquina real, isto é, um computador real feito de hardware e executando um
sistema operacional específico, uma máquina virtual é um computador fictício criado por um
programa de simulação. Sua memória, processador e outros recursos são virtualizados. A
virtualização é a interposição do software (máquina virtual) em várias camadas do sistema. É uma
forma de dividir os recursos de um computador em múltiplos ambientes de execução.
Ultimamente, é muito simples e fácil criar uma máquina virtual: basta apenas instalar um programa
específico dentro da máquina real, onde dentro desse programa poderá ser criado um disco rígido
virtual e a partir disso, será possível executar um sistema operacional inteiro por meio dele.
Entre os programas que simulam essas máquinas, são bastante conhecidos os emuladores de vídeo
games antigos e os emuladores de microcomputadores, como o VMware Player e o Bochs.
Apesar de alguns desses programas serem pagos, existem também softwares livre de fácil acesso,
que é o caso do VM VirtualBox (software livre da Oracle).
Funcionamento.
Após a instalação do programa para criação da máquina virtual, é possível criar um disco rígido
virtual, e a partir disso, é possível executar um sistema operacional inteiro.
A máquina virtual irá alocar, durante a execução de sistemas operacionais, uma quantidade
definida de memória RAM. Ela normalmente emula um ambiente de computação física, mas
requisições de CPU, memória, disco rígido, rede e outros recursos de hardware serão todos geridos
por uma "camada de virtualização" que traduz essas solicitações para o hardware presente na
máquina.
A partir disso, é possível a instalação de outros softwares dentro do presente software, fazendo
simulações em geral sem a necessidade um hardware específico.

Uso por teste.

O conceito de VM também pode ser utilizado como máquinas virtuais a efeito de testes, ou seja,
quando empresas de desenvolvimento desejam testar seus produtos ou até mesmos administradores
de redes, sistemas pretendem montar protótipos e projetos futuros.
Caso se trate de uma pequena e média empresa onde os recursos são reduzidos, podemos utilizar
o Conceito de VM, para que um servidor de arquivos além de armazenar dados, também possua
uma outra tarefa como por exemplo instalação de um (Servidor Jabber "comunicação", servidor
CUPS "impressão" e até mesmo um Postfix "correio eletrônico").

Classificação das máquinas virtuais

1 - Máquinas virtuais de sistemas – são ambientes de máquinas virtuais construídas para emular
uma plataforma de hardware completa, com processador e periféricos. Este tipo suporta sistemas
operacionais convidados executando sobre eles.
Exemplo: KMV, VMware e Virtualbox.
2 - Maquinas virtuais de sistemas operacionais – São construídas para suportar espaços de
usuários distintos sobre um mesmo sistema operacional. Embora compartilhem o mesmo núcleo,
cada ambiente virtual possui seus próprios recursos lógicos, como espaço de armazenamento,
mecanismo de IPC e interfaces de rede distintas.
Exemplo: Docker, Solaris Containers e FreeBSD jails.
3 - Máquinas virtuais de processos – Também chamadas de máquinas virtuais de aplicação ou
de linguagem, são ambientes construídos para prover suporte de execução a apenas um processo
ou aplicação convidada específica.
Exemplo: Valgrid, Virtual java.
Tipos de máquinas virtuais.
As máquinas virtuais podem ser divididas em três tipos:

Tipo 1: Sistema em que o monitor é implementado entre o hardware e os sistemas convidados

(guest system), onde o monitor tem controle sobre o hardware e abre sessões (convidados) para
criação de máquinas virtuais semelhantes ao sistema operacional tradicional.

Tipo 2: Nele o monitor é implementado como um processo de um sistema operacional real,

denominado sistema anfitrião (host system), onde o monitor é executado como um Processo por
um Sistema Anfitrião, ou seja, um sistema gerencia o acesso do hardware ao monitor, que por sua
vez cria máquinas virtuais assim como descrito no Tipo 1.

Tipo 3: Utiliza os 2 conceitos do Tipo 1 e Tipo 2 ao mesmo tempo. Em resumo é a capacidade da

máquina virtual (sistema convidado) de acessar diretamente o hardware, sem ter que passar todas
informações ao monitor toda vez que desejar acessar algum dispositivo/hardware.

Tipos Híbridos: Os monitores de tipo 1 e 2 raramente são usados em sua forma conceitual em
implementações reais. Na prática, várias otimizações são inseridas nas arquiteturas apresentadas,
com o objetivo principal de melhorar o desempenho das aplicações nos sistemas convidados.
Como os pontos cruciais do desempenho dos sistemas de máquinas virtuais são as operações de
E/S, as principais otimizações utilizadas em sistemas de produção dizem respeito a essas
operações.
Outra importante categoria de máquinas virtuais são as máquinas virtuais para computadores
fictícios projetados para uma finalidade específica. Atualmente a mais importante máquina virtual
desta família é a JVM (máquina virtual Java). Existem simuladores para ela em quase todos os
computadores atuais, desde computadores de grande porte até telefones celulares, o que torna as
aplicações Java extremamente portáveis.
Uma importante vantagem sem duvida de se escrever código para uma máquina virtual é a de se
poder compilar o código sem que seja perdida a portabilidade, melhorando-se a velocidade em
relação à programação interpretada, que também é portátil, porém mais lenta, já que neste caso
cada linha será traduzida e executada em tempo de execução, e no caso da máquina virtual
cada mnemônico da máquina virtual é convertido no equivalente em linguagem de máquina
(ou assembly) da máquina real.

Vantagens.

1. Facilita o aperfeiçoamento e testes de novos sistemas operacionais.

2. Possibilita a comparação de vários sistemas operacionais utilizando o mesmo equipamento.
3. Executa diferentes sistemas operacionais sobre o mesmo hardware, simultaneamente.
4. Simula alterações e falhas no hardware para testes ou reconfiguração de um sistema
operacional, provendo confiabilidade e escalabilidade para as aplicações.
5. Diminuição de custos com hardware.
6. Facilidades no gerenciamento, migração e replicação de computadores, aplicações ou sistemas
operacionais.
7. Confiança e disponibilidade: A falha de um software não prejudica os demais serviços.
8. O isolamento da máquina virtual assegura que as aplicações e serviços que serão executados
dentro de uma máquina virtual não poderão interferir no sistema operacional original e nem
em outras máquinas virtuais.
9. Pode ser facilmente deslocadas, copiadas e transferidas entre computadores, possibilitando
aperfeiçoar os recurso do hardware.
10. Teste de diversos sistemas operacionais sem precisar particionar o HD, podendo instalar
versões antigas do Windows, Linux, ou qualquer outro sistema sem fazer alterações no disco
rígido.
Desvantagens.

 Gerenciamento: Os ambientes virtuais necessitam ser, monitorados, configurados e salvos .

Existem produtos que fornecem essas soluções, mas esse é o campo no qual estão os maiores
investimentos na área de virtualização, justamente por se tratar de um dos maiores
contratempos na implementação da virtualização.
 Desempenho: Atualmente, não existem métodos consolidados para medir o desempenho de
ambientes virtualizados. No entanto, a introdução de uma camada extra de software entre o
sistema operacional e o hardware, o VMM ou hypervisor, gera um custo de processamento
superior ao que se teria sem a virtualização. Outro ponto importante de ressaltar é que não se
sabe exatamente quantas máquinas virtuais podem ser executadas por processador, sem que
haja o prejuízo da qualidade de serviço.
 Enorme uso da memória da maquina real, depois de uma grande tempo de estar em modo
ligada. Isso ocasiona lentidão para o usuário que está utilizando.

Segurança.
Embora a máquina necessite do sistema real para sua inicialização, trabalha de maneira
independente como se fosse outro computador, isto requer também um sistema de segurança
independente, ou seja, a ocorrência de infecção por vírus na máquina virtual não afeta a máquina
real.
Em geral o conceito sobre máquinas virtuais vem crescendo, não só pela performance apresentada
nos resultados, mas pelo custo reduzido de hardware e manutenção, o que facilita muito o uso
desses softwares.

Tipos

 VMware Player
 VirtualBox
 Bochs
 QEMU
 oVirt
 Kernel-based Virtual Machine
 Virtual PC
 Parallels Desktop
Conclusão
Ao realizar o trabalho podemos constatar que o sistema monolítico é o mais rápido pois não possui
muita complexidade e possui um bom desempenho, o sistema em camada possibilita a
modularidade, fácil depuração e atualização fácil. Os sistemas micronúcleos possui um baixo
desempenho e são mais estáveis.
A escolha do tipo de máquina virtual depende da finalidade, pois existem máquinas virtuais para
trabalhar com processos, para trabalhar com sistemas e sistemas operativos.
Elas possibilitam o aperfeiçoamento e testes de novos sistemas operacionais, diminuição de custos
em hardware.
Referencias Bibliográficas
Marcos Laureano, Maquinas Virtuais e Emuladores – Conceitos, Técnicas e Aplicações. Novatec
Editora. ISBN 85-7522-098-5.
Diogo Menezes Ferrazani Mattos, Vantagens e Desvantagens.
Pt.m.Wikipedia.org.
TANENBAUM, Andrew S. Sistemas Operacionais: projecto e Implementacao. Andrew S.
Tanenbaum e Albert S. Woodhull; trad Edson Furmankiewick. – 2ª Ed. – Porto Alegre, Bookman,
2000.