Algoritmos de trocas de páginas

Por Taiany Géssica e David Rocha

Algoritmos de trocas de páginas

Os algoritmos de trocas de páginas são políticas definidas para escolher quais páginas da memória dará lugar à página que foi solicitada e que precisa ser carregada. Isso é necessário quando não há espaço disponível para armazenar a nova página.

O sistema operacional deverá escolher, entre as páginas que estão na memória principal, uma para remover e permitir que a nova página seja trazida para a memória. Se esta página a ser removida foi modificada enquanto estava na memória, ela deverá ser salva no disco antes de poder trazer a nova página. Caso uma página que é freqüentemente acessada seja removida da memória, muito provavelmente ela deverá ser trazida de volta a memória em um curto período, causando um gasto de tempo evitável.

Para gerenciar a memória, e evitar que páginas freqüentemente acessadas sejam removidas da memória, são utilizados os algoritmos de troca de página.

Esses algoritmos que tratam dos problemas de trocas de páginas são aqueles que implementam as estratégias de substituição (replacement strategies) e são denominados algoritmos de troca ou algoritmos de substituição de páginas.

Neles podemos destacar os algoritmos Random, First In First Out, Second Chance, Clock, Clock 2, Last Recently Used (LRU), Last Frequently Used (LFU), Not Recently Used (NRU).

O Algoritmo de troca de páginas Random Page Replacement é um algoritmo de baixa sobrecarga que seleciona aleatoriamente a página que deverá ser substituída.

Suas chances de sucesso são maiores quando há um maior número de páginas existentes. É um algoritmo rápido e de implementação simples, mas é raramente utilizado, pois a página a ser substituída pode ser a próxima a ser necessária.

O First In First Out (FIFO) é um algoritmo que tem como idéia central que as páginas que estão há mais tempo na memória podem ser substituídas, ou seja, as primeiras que entram são as primeiras que saem. Para isto associa se um timepstamp (Marca de tempo), que cria uma lista de páginas por idade, ou seja, por entrada. Cada nova página trazida à memória é colocada no final de uma lista ligada. Ao ocorrer uma falta de página, a página que estiver no começo desta lista será removida. Embora esse algoritmo seja provável e lógico não necessariamente é correto, pois páginas há mais tempo na memória podem ser usadas com muita freqüência. Assim ele não é utilizado da forma pura, mas sim com suas variações.

O Second Chance (Segunda Chance) é uma variação da estratégia FIFO. Como a deficiência do FIFO é que uma página de longa duração e de uso intenso pode ser indevidamente substituída. O algoritmo de troca de páginas segunda chance escolhe a página mais antiga, porém antes de fazer a substituição verifica o bit de referência da mesma. Se o bit estiver em 1, significa que a página foi usada, assim o algoritmo troca sua marca de tempo (timepstamp) e ajusta o bit de referência para zero, simulando uma nova página na memória. Ele fornece uma “segunda chance” para as às páginas antigas de permanecerem na memória primaria.

Basicamente, esse algoritmo trabalha fazendo com que as páginas fiquem em uma lista onde no início se encontram as páginas mais velhas que se após a verificação constatar que a página foi usada será reposicionada para o final (mais novas).

O algoritmo de troca de páginas Clock (relógio) é outra variação da estratégia FIFO. Enquanto o algoritmo de troca de páginas FIFO substitui uma página em função de sua idade na memória e o algoritmo second chance verifica o bit mantendo na memória páginas de uso intenso através da renovação de seu timestamp. O clock mantém uma lista circular, onde se o bit de referência é 1 o seu valor é trocado por zero, e a referência da lista é movida conforme os ponteiros de um relógio, caso contrario a página será substituída.

O clock 2 é igual ao Clock, só que existem 2 ponteiros, enquanto um vai apagando os bits R, o outro verifica se a página pode ser removida.

O algoritmo de troca de paginas LRU (least Recently Used ou menos usada recentemente) tem como funcionalidade identificar a página menos utiliza por mais período de tempo.

É necessário que cada página possua o timestamp. Ele tem como idéia que as páginas usadas recentemente logo não serão usadas e retira da memória a página que há mais tempo não é utilizada.

A implementação ocorre através de listas, sendo que a página mais recentemente usada se localiza no início da lista e a menos usada no final. É necessário atualizar a lista a cada referência à memória.

Sua deficiência ocorre em laços longos ou chamados com muitos níveis de profundidade, pois a próxima pagina a ser usada pode ser uma das menos usadas recentemente.

O Least Frequently Used – LFU (Menos usada frequentemente) ou Not Frequently Used – NFU (Não usada frequentemente) são algoritmos de estratégia para o LRU, que calcula a freqüência de uso das páginas de forma a identificar qual página foi menos intensivamente utilizada. Sua deficiência é que ainda é possível páginas pesadas que foram utilizadas durante uma certa etapa do processamento permaneçam sem necessidade na memória primária em relação a outras etapas mais curtas, cujas páginas não terão uso tão intenso, levando a substituições inúteis.

O algoritmo NRU (Not Recently Used) tem como idéia escolher a página que está há mais tempo sem uso para efetuar a troca, sendo que a página mais recente é excluída da decisão e através do método FIFO, é feita a escolha dentre as outras de qual página deve sair. Este algoritmo é utilizado em vários sistemas devido sua forma simples, de fácil implementação e desempenho adequado.

Exemplos de S.O

No Linux, a memória funciona com prioridade para processos que estão em execução. Quando um processo termina, havendo espaço na memória, o sistema mantém resíduos desse processo na memória para que uma possível volta a processo seja mais rápida. Caso essa memória RAM esteja lotada com processos que estão em execução, aí se faz uso da memória SWAP (troca).

O sistema operacional MS Windows 95 utiliza a estratégia de substituição de páginas LRU (least recently used ou menos usada recentemente).

Paginação de memória.

Este trabalho consiste na explicação do tema: Paginação de memória.
Diogo Libana / Francisco Henrique

1.1 Conceitos de paginação

A técnica de paginação surgiu com a necessidade de evitar o desperdício de memória causada pelas partições variáveis em função da fragmentação externa. A fragmentação externa consiste no fato de cada programa necessitar ocupar uma área continua na memória, se essa necessidade for eliminada e partes do programa puderem ser espalhadas pela memória, o problema da fragmentação externa estaria acabado e é ai que entra a paginação. A paginação nada mais é que o programa poder ser espalhado por áreas não continuas da memória.
A paginação ocorre quando o programa é executado, o mesmo é escrito com a suposição de que ele vai ocupar uma área continua na memória, ou seja, que ocupará a memória lógica. O endereço da memória lógica é dividido em duas partes o numero da página lógica e o deslocamento dentro da memória lógica.

Exemplo de memória física/lógica
Num. Des. Mem
000 | 00 | A1
000 | 01 | A2
000 | 10 | A3
000 | 11 | A4

O a primeira coluna (Num.), é o numero da pagina lógica, a segunda coluna (Des.) é o deslocamento dentro da tabela, ao ser criada a pagina lógica é também criada a página física com o mesmo formato da página lógica só diferem que a memória física não necessita que suas páginas estejam na mesma ordem que as páginas na memória lógica, mas precisa que o deslocamento dentro das páginas seja o mesmo tanto na memória física quanto na lógica, por tanto a página da memória física será carrega com o mesmo formato da memória lógica, tendo diferente apenas seus endereço de página, durante essa carga é criada a tabela de páginas. Essa tabela é usada para saber qual página da memória lógica corresponde à página da memória física.

1.2 Tabela de páginas

Cada entrada na tabela de páginas possui o endereço da pagina lógica para a página física, assim se obtendo o endereço da página física correta, já o endereço de deslocamento da página é o mesmo tanto para a página física quanto para a página lógica. Agora juntamos os dois números primeiro o endereço da página depois o deslocamento e temos o endereço físico do byte em questão na tabela física a figura abaixo mostra com mais clareza como é feito esse processo na tabela de páginas.

Vamos pegar o exemplo de Y2, na página lógica Y2 tem o seguinte endereço página 001 e deslocamento 01, pegando o numero da página lógica e comprando na tabela de páginas sabemos que o numero da página física de Y2 é 101 e como o deslocamento é igual em ambas as paginas 01, descobrimos o endereço do byte Y2 na página física 101 01.
O tamanho de uma página pode variar entre 1Kbytes a 8Kbytes, os espaços de endereçamento lógico variam nos Gbytes para máquinas atuais, a memória física vem da capacidade de endereçamento do processador e não a quantidade de memória que é instalada na máquina.
No processo de paginação a unidade de alocação sempre ocupa um numero inteiro de páginas físicas, assim gerando uma fragmentação interna. Imagine o exemplo, um programa precisa de 26Kbytes para ser executado e o tamanho de cada página é 4Kbytes iriam ser ocupadas pelo programa sete páginas totalizando 28Kbytes e gerando assim uma fragmentação interna de 2Kbytes e geral é esperada uma fragmentação interna de página/2 para cada processo.

1.3 Tamanho das paginas
Aqui abordaremos as vantagens e as desvantagens em utilizarmos grandes paginas durante o processo de paginação.
Quanto maior a página menores serão os gastos com a tabela de páginas e aumentará a eficiência da (E/S) do disco, ao mesmo tempo paginas maiores resultam em uma maior fragmentação interna. O tamanho das paginas não é definido pela arquitetura do SO, quem é responsável por isso é o hardware que gerencia a memória.
O gerenciador de memória tem que manter um controle sobre as paginas que estão preenchidas e as que não estão preenchidas, uma forma de realizar esse controle é com o um mapa de bits onde indica um para página usada e zero para página livre, bastaria o gerenciador percorrer suas páginas e encontrar a primeira livre (zero) mas imagine uma memória física de 1Gbytes com quase toda sua extensão já preenchida esse processo iria demorar um pouco. A alternativa para contornar esse problema é manter uma lista encadeada com os números das páginas livres. Com essa lista bastaria pegar o primeiro numero da lista e o sistema gerenciador de memória não precisaria ficar percorrendo toda a extensão da memória toda vez que precisasse de uma pagina livre.

1.4 Níveis de paginação

Uma possibilidade para implementação da paginação de memória seria a tabela de página ser criada de forma contínua, porém deste modo haveria fragmentação de memória no que se refere as tabelas, para solucionar este problema dividiu-se a tabela de página em níveis, o mais comum é o gerenciamento de dois níveis de tabelas, um contendo um diretório de tabelas e outro contendo as tabelas de segundo nível, deste modo as tabelas são criadas de acordo com a demanda e indexadas neste diretório, como mostramos na figura abaixo:



1.5 Exemplo de paginação no linux

No Linux, um endereço virtual é dividido em 5 campos: diretório de páginas (PGD), diretório superior de páginas (PUD), diretório intermediário de páginas (PMD), tabela de páginas (PTE) e deslocamento (offset). A arquitetura x86 possui um espaço de endereçamento de 32 bits; quando são utilizadas páginas de 4 KiB (o padrão) o PUD e o PMD não são utilizados; o PGD e o PTE usam 10 bits cada, e o deslocamento usa 12 bits.

Memória virtual + Segmentação

Aluno: Andre Ferreira Fiche

MEMÓRIA VIRTUAL

É a técnica de gerenciamento que combina a memória principal e a secundária dando ao usuário uma idéia de que existe mais memória principal.
*Desvincula o endereçamento feito pelo programa dos endereços físicos da memória principal;
*Um programa residente na memória virtual faz referências a endereços virtuais;
*O endereço virtual é traduzido para o endereço físico através de mapeamento;
*Os programas podem ser muito maiores que a sua memória física, apenas uma parte do programa está residente na memória em um determinado instante, o restante do programa fica na memória secundária até ser referenciado.

SEGMENTAÇÃO

• A memória virtual discutida até agora é unidimensional, dado que vai de 0 até um endereço máximo.
Em alguns casos isto representa um problema
Tomemos como exemplo a execução de um compilador, que durante a sua execução gera.

1. O texto fonte pre-processado.
2. Uma tabela de símbolos
3. Uma tabela de constantes
4. Uma árvore sintática
5. Uma pilha.

• Os quatro 1º itens crescem continuamente durante a compilação, enquanto a pilha varia de tamanho.
Em uma memória unidimensional estas informações teriam que serem colocadas de
forma contínua no espaço de endereçamento virtual
Imagine o que acontece quando um programa tem um número extremamente grande de variáveis e todo o resto normal.

Nota-se a necessidade de um mecanismo capaz de livrar o programador da contração e expansão de tabelas, da mesma maneira que a memória virtual elimina a preocupação de organizar o programa em overlays
Uma solução extremamente direta é prover a máquina com vários espaços de endereçamento independentes, chamados segmentos
Cada segmento tem um tamanho dinâmico e independente dos outros (de 0 a um máximo)

Para especificar um endereço nesta memória segmentada e bidimensional, o programa deve fornecer um endereço composto de 2 partes: um no. de segmento e um endereço dentro do segmento
Permite que cada tabela cresça ou encolha, Independentemente.
É preciso enfatizar que cada segmento é uma entidade lógica conhecida e utilizada pelo programador, normalmente para armazenar informações relacionadas.
Segmentos podem ter diferentes proteções

– EX: um segmento que armazena código pode ser marcado como somente execução
– Um segmento que armazena constantes, como somente leitura.
– Segmento que possui a pilha como leitura/escrita

• Tentativas de acesso indevidas podem ser capturados e tratados pelo hardware ou SO.
A proteção faz bem mais sentido em uma memória segmentada que em uma paginada, dado que o conteúdo de cada página (ao contrário do conteúdo de cada segmento) é acidental
Embora seja possível se colocar alguns bits de proteção em cada entrada na tabela de pág. a fim de especificar o acesso permitido, o programador deveria manter o controle de onde estão os limites das pág. em seu espaço de endereçamento, para poder utilizar esta propriedade.
A paginação foi criada exatamente para livrar o programador deste tipo de tarefa.

A segmentação difere da paginação em um ponto essencial: as pág. tem tamanho fixo e os segmentos não.
A figura a seguir mostra um exemplo de memória física com cinco segmentos, onde ocorrem as seguintes operações.

1. O seg. 1 é removido e o 7 colocado em seu lugar
2. O seg. 4 é removido e o 5 colocado em seu lugar
3. O seg. 3 é removido e o 6 colocado em seu lugar
(a)-(d) Desenvolvimento de fragmentação externa
(e) Remoção da fragmentação via compactação

• Após algum tempo de execução a memória estará dividida em regiões com segmentos ou lacunas.
Este fenômeno, chamado de fragmentação externa desperdiça memória nas lacunas
Isto pode ser sanado com a compactação dos segmentos.

HIBRIDO

Se os segmentos são grandes talvez seja desnecessário, ou mesmo impossível mantêlos totalmente na memória
Isto gerou a idéia de paginação dos segmentos, de modo que apenas as pág. de cada segmento realmente necessárias terão que estar na memória
Esta paginação funciona exatamente da mesma maneira que de modo isolado, só que divide o espaço de endereçamento de cada seg. em pág., ao invés do espaço de endereçamento como um todo
Várias arquiteturas e SO suportam e utilizam sementos paginados (ex: intel x86 e os SO Linux e Windows)

O Escalonamento de Processos no Mac OS

Por Vítor Rideik e Thiago Carrere

O escalonamento de processadores é a forma com os processadores existentes
Num sistema computacional são utilizados para efetuar o processamento,
Isto é, é como os processos são distribuıdos para execução nos Processadores.

Tanenbaum propõe a seguinte definição:

Quando mais de um processo é executável, o sistema operacional
Deve decidir qual será executado primeiro. A parte do sistema operacional dedicada a esta decisão é chamada escalonador (scheduler) e o algoritmo utilizado é chamado algoritmo de escalonamento
(scheduling algorithm). [TAN92, p. 62]

O escalonador de processos do Mac OS X é derivado do escalonador OSFMK, porém várias modificações foram feitas para o tratamento de interatividade no projeto de escalonador base.
Assim como o kernel do FreeBSD (5.0BSD), o escalonador de processos do Mac OS X escalona os processos baseado numa variante do algoritmo de múltiplas filas com realimentação, porém divide as filas de prioridades em 4 grupos de processos, agrupados de acordo com suas características.

1. Normal: Prioridade das aplicações normais do usuário.
   
2. Sistema: Prioridade das aplicações do sistema, com prioridade superior as threads normais de usuário.
   
3. Kernel: Classe reservada para threads em espaço de kernel que necessitam rodar
   Com uma prioridade superior às threads de sistema.
   
4. Tempo real Threads nas quais a prioridade está baseada na necessidade de reservar
   uma fração pré-definida de ciclos de clock, independente de outras
   atividades sendo executadas no sistema.

No caso de tarefas de tempo real, È feito um controle forte pela aplicação no número de ciclos do processador a serem utilizados. Assim, o programador utiliza chamadas de sistema para requisitar ao sistema rodar por A ciclos nos próximos B ciclos. Por exemplo, um processo de tempo real pode requisitar ao kernel que, para que ele possa executar corretamente dentro dos seus padrões mínimos aceitáveis, ele necessite, a cada 7000 ciclos, 3000 ciclos reservados a ele.

Caso a aplicação não respeite o número de ciclos requisitados, ou seja, não faça uma operação de E/S ou use a chamada de sistema sched yield, um processo de tempo real será penalizado dentro de sua fila de prioridades, sendo inclusive possível a migração para o grupo de processos Normal, visando um maior desempenho e justiça no sistema.

A escolha do processo a ser executado obedece o algoritmo de Múltiplas Filas com realimentação, sendo executados os grupos de filas de maior prioridade (Tempo real) e por último o grupo de filas de prioridade de usuário (Normal).
A migração entre os diferentes grupos de threads e feita através do nível de prioridade explicitada pelo usuário. A migração entre as filas de prioridade dentro do grupo de tarefas de usuário é determinada pelo determinador de interatividade.

Como o Sistema Operacional gerencia a memória

Ricardo Verzi e Michele Martins

Alocação Contígua Simples: A forma mais simples de gerenciar a memória é dividindo ela em duas partes, mais conhecida como Alocação Contígua Simples, uma parte para o S.O e a outra para o uso dos processos do usuário. A parte dedicada aos processos do usuário é subdivida em partições de tamanhos iguais ou diferentes porem sempre fixas, a alocação contígua simples era utilizada em antigos S.O.
Multiprogramação com Partições Fixas: A principal virtude desse modelo de gerenciamento de memória reside no fato de que a CPU pode ser utilizada de uma maneira mais proveitosa. Em sistemas de compartilhamento de tempo, ter múltiplos processos na memória simultaneamente significa que quando um processo é bloqueado esperando a E/S acabar, outro pode utilizar a CPU.

O S.O. é responsável pelo controle das partições mantendo informações como partições alocadas, partições livres e tamanho das partições. Quando o sistema operacional gerencia a memória do computador, duas grandes tarefas precisam ser cumpridas.
1. Cada processo deve ter memória suficiente para ser executado. Ele não pode utilizar a memória de outro processo e outro processo também não pode utilizar a sua memória.
2. Os diferentes tipos de memória no sistema devem ser bem utilizados para que cada processo seja executado de forma eficaz.

Paginação: Quando o computador tem pouca memória RAM e precisa de mais imediatamente, o Windows usa o espaço em disco rígido para simular memória RAM do sistema. Isso é conhecido como memória virtual e é freqüentemente denominado arquivo de paginação. O tamanho padrão do arquivo de paginação da memória virtual (denominado pagefile.sys) criado durante a instalação tem 1,5 vezes a quantidade de RAM do computador.
É possível otimizar o uso da memória virtual dividindo o espaço entre as várias unidades e removendo-a de unidades mais lentas ou muito acessadas. Para melhor otimizar o espaço da memória virtual, divida-o entre o maior número possível de discos rígidos físicos. Ao selecionar unidades, tenha as seguintes diretrizes em mente:
- Evite ter um arquivo de paginação na mesma unidade que os arquivos de sistema.
- Não coloque vários arquivos de paginação em partições diferentes no mesmo disco rígido físico.

Limite mínimo recomendado e máximo de memória física

WINDOWS XP

Windows XP Professional – 32 bit
Mínimo recomendado 128 MB
Máximo recomendado 4 GB

Windows XP Professional – 64 bit
Mínimo recomendado 256 MB
Máximo recomendado 16 GB

WINDOWS VISTA

- Windows Vista Ultimate
Mínimo 512 MB
Recomendado 1 GB
Máximo 125 GB

- Windows Vista Home Premium
Mínimo 521 MB
Recomendado 1 GB
Máximo 16 GB

Escalonamento no Windows XP

Por Jones Henrique e Luiz Valério

Escalonamento de Processos

O escalonamento de processos ou agendador de tarefa é uma atividade organizacional feita pelo escalonador (scheduler) da CPU ou de um sistema distribuído, possibilitando executar os processos mais viáveis e concorrentes, priorizando determinados tipos de processos, como os de I/O Bound e os computacionalmente intensivos.

O escalonador de processos de 2 níveis escolhe o processo que tem mais prioridade e menos tempo e coloca-o na memória principal, ficando os outros alocados em disco; com essa execução o processador evita ficar ocioso.

Escalonamento no Windows XP

O Windows XP é um sistema operacional gráfico de 32bits, multitarefa preenptiva e plug and play que aproveita melhor os recursos das máquinas de 386 para cima.

Multitarefa é a capacidade que o Windows tem de executar vários processos (aplicativos) ao mesmo tempo. Existem dois modos de Multitarefa: a multitarefa preemptiva que é utilizada por aplicativos de 32 bits baseados em Windows 95 e a multitarefa cooperativa que é utilizada por aplicativos de 16 bits baseados em Windows 3.1.

Em um sistema Multitarefa preemptivo, cada encadeamento é executado durante um tempo determinado ou até que outro encadeamento de prioridade maior esteja pronto para ser executado. Como o agendamento é controlado pelo sistema operacional sem a cooperação do aplicativo, torna-se mais difícil para um programa ou encadeamento monopolizar o processador. Para impedir que encadeamentos de processos diferentes tenham acesso a um recursos que não podem ser compartilhados (como uma porta serial), o programa pode definir semáforos (sinalizadores especiais utilizados pelo programa) para bloquear este recurso até que ele termine de ser utilizado. No Windows XP, programas do MS-DOS e de 32 bits baseados no Windows são Multitarefa Preemptiva.

Em sistema Multitarefa cooperativos (também denominados não-apropriativos), um encadeamento é executado até que voluntariamente abandone o processador. O programa determina quando o encadeamento pára a execução. No Windows XP, programas de 16 bits baseados no Windows são Multitarefa de modo cooperativo, entre si. Todos os programas de 16bits baseados no Windows, juntos, são tratados como uma única tarefa para o Multitarefa Preemptivo. Este processo Multitarefa híbrido é necessário para manter a compatibilidade com programas de 16 bits baseados no Windows que controlam sua própria execução.

Threads com Java

por Peter Jandl Jr

Threads
Uma thread define um fluxo de execução independente dentro de um programa e permite
que sejam isoladas tarefas específicas dentro deste. Como as threads são partes do mesmo programa, i.e., fazem parte de um mesmo contexto computacional, então os recursos do
sistema reservados para um programa estão disponíveis para todas as suas threads, e por isso
as threads são consideradas processos leves. Em sistemas onde as threads são suportadas,
programas com um único fluxo de execução (programas sequenciais comuns) são denominados
single-threaded ou de thread única. Já aqueles que definem múltiplos fluxos de execução são
chamados de multithreaded.

O uso das threads pode tornar um programa eficiente e versátil, garantindo que sua interface
se mantenha responsiva, mesmo enquanto o programa executa suas tarefas, ou permitindo
que várias tarefas sejam realizadas ao mesmo tempo.

O uso de threads na plataforma Java é relativamente simplificado, sendo que sua API Java inclui classes especialmente destinadas ao uso e controle das threads que são: Thread e ThreadGroup, além da interface Runnable.

A Classe Thread
A classe Thread, pertencente ao pacote java.lang, permite representar um fluxo independente
de execução dentro de um programa. Basicamente define-se uma nova thread através da
criação de uma subclasse de Thread, na qual se implementa o método run(), que contém o
código que a ser executado. Por exemplo:

class MinhaThread extends Thread {
public void run() {
System.out.println("Inicio: " + getName());
for (int i=0; i<5;>
System.out.println(i + "-" + getName());
}
System.out.println("Fim: " + getName());
}
}
Uma thread assim definida imprimirá no console a contagem de 0 até 5, acompanhada de
seu próprio nome. No início e fim do método run() ocorre a impressão de uma mensagem
indicativa. Para criar uma thread declara-se um objeto de classe e usa-se o operador new
para instanciar o novo objeto (tal como para qualquer outro objeto Java) definindo ou não
um nome para a nova thread:

MinhaThread minhaThread1 = new MinhaThread();
MinhaThread minhaThread2 = new MinhaThread("A Minha Thread");

A instanciação de uma thread não basta para colocá-la em execução. É necessário iniciá-la
explicitamente através do método start(), que providencia o escalonamento da thread pelo
sistema operacional e a consequente execução do método run(), como segue:

minhaThread1.start();

Segue um outro exemplo:

public class TestaThreads {
public static void main(String a[]) {
System.out.println("Inicio: main");
MinhaThread mt1 = new MinhaThread(),
mt2 = new MinhaThread(), mt3 = new MinhaThread();
mt1.start(); mt2.start(); mt3.start();
System.out.println("Fim: main");
}
}
class MinhaThread extends Thread {
public void run() {
System.out.println("Inicio: "+ getName());
for (int i=0; i<5;> System.out.println(i + -"+ getName());
System.out.println("Fim: "+ getName());
}
}

Se executado, este exemplo produz o seguinte resultado:
Referências

• JANDL JR. Peter. Java 6 - Guia de Consulta Rápida. São Paulo: Novatec, 2008.
• JANDL JR. Peter. Java - Guia do Programador. São Paulo: Novatec, 2007.
• Sun. Classe Thread. Disponível em:
  http://72.5.124.55/javase/6/docs/api/java/lang/Thread.html
• Sun. Interface Runnable. Disponível em:
  http://72.5.124.55/javase/6/docs/api/java/lang/Runnable.html

Threads

Por Mariane e Miriam

O que são Threads?

Uma thread é um pequeno programa que trabalha como um subsistema independente de um programa maior e que executa alguma tarefa específica. Um programa dividido em várias threads pode rodar mais rápido que um programa monolítico, pois várias tarefas podem ser executadas ao mesmo tempo. As threads de um programa podem trocar dados entre si e  compartilhar o mesmo espaço de memória e os mesmos recursos do sistema.

Uma thread (linha de execução) permite que o usuário do programa, por exemplo, utilize uma funcionalidade do ambiente enquanto outra thread realiza outros cálculos e operações.

Em hardwares equipados com uma única CPU, cada thread é processada de forma aparentemente simultânea, pois a mudança entre uma linha e outra é feita de forma tão rápida que para o usuário isso está acontecendo paralelamente. Em hardwares com múltiplos CPUs ou multi-cores as threads podem ser realizadas realmente de forma simultânea.

Os sistemas que suportam apenas uma thread são chamados de monothread e aqueles sistemas que suportam múltiplas threads são chamados de multithread.

Um benefício do uso de threads (linha de execução) além do fato do processo poder ser dividido em mais de uma linha de tarefas é que quando uma linha está esperando determinado dispositivo de I/O ou qualquer outro recurso do sistema, o processo como um todo não fica parado, pois quando uma linha de execução entra no estado de bloqueio uma outra thread aguarda na fila de “prontos para executar”.

A comunicação entre threads é muito rápida por que elas compartilham tudo: espaço de endereçamento, variáveis globais, memória, etc. Desse jeito elas aumentam o desempenho da aplicação, pois não envolvem mecanismos lentos de intercomunicação.

Deve-se tomar cuidado com o numero de threads criadas. O excesso pode causar overhead no sistema ocasionando uma queda de desempenho.

Estados de uma Thread

Uma thread pode assumir os seguintes estados:

Ø Criação: o processo pai está criando a thread que é levada a fila de “prontos para executar”;

Ø Execução: a thread está usando a CPU;

Ø Pronto: a thread avisa a CPU que pode entrar no estado de execução e entra na fila de “prontos para executar”;

Ø Bloqueado: por algum motivo, a CPU bloqueia a thread, geralmente enquanto aguarda algum dispositivo de I/O;

Ø Término: são desativados os contextos de hardware e a pilha é deslocada.

Tipos Implementação de Threads

As threads podem ser oferecidas por uma biblioteca de rotinas fora do núcleo do sistema operacional (modo usuário), pelo próprio núcleo do sistema (modo Kernel), por uma combinação de ambos (modo híbrido) ou por um modelo conhecido como Scheduler Activations.

Modo Usuário (TMU)

As threads são implementadas pela aplicação e não pelo sistema operacional. Como ele não sabe da existência de múltiplas threads cabe a aplicação gerenciar e sincronizar as diversas threads existentes.

Existem vantagens e desvantagens em todos os casos:

Vantagens

Ø Permitem a implementação de threads mesmo em sistemas operacionais que não suportam threads;

Ø Como dispensam o acesso ao kernel do sistema, são rápidos e eficientes.

Desvantagens

Ø O sistema operacional gerencia o processo como se houvesse uma única thread. Quando uma thread chama uma rotina do sistema que o coloca em estado de espera, todo o processo é colocado em estado de espera, mesmo havendo outras threads prontas para execução;

Ø Tratamento individual de sinais. Como o sistema operacional reconhece apenas processos e não threads, os sinais enviados para um processo devem ser reconhecidos e encaminhados a cada thread para tratamento;

Ø Redução do grau de paralelismo. O sistema seleciona apenas processos para execução e threads de um processo podem ser executadas somente em um processador de cada vez.

Modo Kernel (TMK)

São implementadas diretamente pelo núcleo do sistema operacional.

Vantagens

Ø O sistema operacional sabe de cada thread que existe e assim pode escaloná-las individualmente;

Ø Caso haja múltiplos processadores, threads de um mesmo processo podem ser executadas simultaneamente.

Desvantagens

Ø Baixo desempenho. Há varias mudanças no modo de acesso, pois enquanto no modo do usuário todo o tratamento era realizado sem a ajuda do sistema operacional aqui são utilizadas as rotinas do sistema.

Modo Híbrido

Combina vantagens de threads implementadas em modo usuário e threads implementadas em modo Kernel.

Um processo pode ter vários threads em modo Kernel e por sua vez este pode ter vários threads em modo usuário.

Um thread em modo usuário pode ser executado em um thread de modo Kernel e em segundos, ser executado em outro.

Vantagem

Ø Maior flexibilidade.

Desvantagens

Ø Apresenta problemas herdados de ambas as implementações. Por exemplo, uma chamada de bloqueio de uma thread em modo Kernel bloqueia todas as threads de modo usuário, que são colocados em espera;

Ø Reduz o desempenho, pois threads de modo usuário que precisam utilizar diferentes processadores precisam utilizar diferentes threads de modo Kernel.

Scheduler Activations

Ø Os problemas apresentados nos threads de modo híbrido existem devido à falta de comunicação entre os threads em modo usuário e modo kernel;

Ø Usa o melhor do modo usuário e do modo kernel, através de uma estrutura de dados chamada Scheduler Activations;

Ø Alcança um melhor desempenho evitando mudanças de modos de acesso que não sejam necessárias;

Ø Caso uma thread utilize uma chamada ao sistema que o coloque no estado de espera não é necessário que o kernel seja ativado, basta que a própria biblioteca escalone outra thread;

Ø Bibliotecas em modo usuário e kernel se comunicam, trabalhando de forma cooperativa.

Exemplos de Threads

Um exemplo bem simples de uma thread é um jogo onde o mesmo pode ser modelado com linhas de execução diferentes sendo uma para desenho de imagem e outra para áudio. Neste caso há uma thread para tratar da imagem e outra para tratar do áudio. Para o usuário, a imagem é desenhada ao mesmo tempo em que o áudio é emitido pelos auto-falantes, porém para sistemas com uma única CPU, cada linha de execução é processada uma de cada vez, separando por escalonamento em milessegundos os processos que estão sendo executados.

Exemplos em C#

Exemplo 1:

No C# existe um suporte a execução paralela de código, através de multithreading. Um programa em C# começa com uma thread principal que é criada automaticamente pelo CLR do .NET Framework e pelo sistema operacional é a thread("main"). Então o programa se torna multithreading a partir da criação de outras threads a partir dessa thread principal.

Exemplo de código de uma thread, mostrando o compartilhamento de recursos em comum como no caso o Console:

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

namespace ThreadTest
{
class Program
{
static void Main(string[] args)
{
Thread minhaThread = new
Thread(new ThreadStart(Escreve));
minhaThread.Start();
for (int i = 0; i < 1000; i++)
{
Console.Write("_");
}
Console.ReadLine();
}
public static void Escreve()
{
for (int i = 0; i < 1000; i++)
{
Console.Write("-");
}
}
}

}

A thread principal ("main"), cria uma nova thread que irá executar a função
Escreve(), esta função mostrará na tela o hífen"-". Ao mesmo tempo em que isso
ocorre, a thread principal escreve na tela "_" (underline). Note que
repetindo a execução varias vezes, o comportamento não se repete.

Exemplo 2:

Se em uma aplicação Windows Form há uma tarefa que consome muito tempo, e que faz essa programação normalmente, o Form irá travar enquanto a aplicação processa essa tarefa.
Com os threads isso pode ser evitado, pois a aplicação irá processar a tarefa "em paralelo" numa outra thread e o Form poderá ser utilizado normalmente.

Código de uma aplicação Console utilizando threads:
class Program
{
//Primeiro criamos um método “void” que não recebe parâmetros
//Esse método fará o trabalho das Threads
static void Trabalho ()
{
Console.WriteLine("Esse é o ID da Thread: " + Thread.CurrentThread.ManagedThreadId);
Console.WriteLine("Esse é o nome da Thread: " + Thread.CurrentThread.Name);
//Apenas escrevemos o ID e o nome da Thread em execução
}
static void Main(string[] args)
{
//Aqui utilizamos uma delegate que recebe nosso método como parâmetro
//Note que esta delegate só pode receber como parâmetro
//um método void que não recebe argumentos
ThreadStart operacao = new ThreadStart(Trabalho);
//Agora já estamos prontos para criar a Thread
//A Thread deve receber como parâmetro a delegate que indica
//o que deve ser executado quando a Thread for iniciada
Thread minhaThread1 = new Thread(operacao);
//Nome da Thread

minhaThread1.Name = "Exemplo-1";
//Aqui inicializamos a Thread, então ela executará o que
//foi especificado pela delegate operação

minhaThread1.Start();
//Aqui executamos o mesmo código novamente para
//iniciar uma segunda Thread e compararmos os IDs
Thread minhaThread2 = new Thread(operacao);
minhaThread2.Name = "Exemplo-2";
minhaThread2.Start();
Console.ReadLine();
}
}

Exemplo 3:

Como a thread funciona, mostrando seu período em que está processando várias coisas paralelamente, em milessegundos, dando impressão ao usuário de que está funcionando tudo ao mesmo tempo, e o estado de parada.

using System;

using System.Threading;

public class Worker

{

// Este método será chamado quando a thread é iniciada.

public void DoWork()

{

while (!_shouldStop)

{

Console.WriteLine("worker thread: working...");

}

Console.WriteLine("worker thread: terminating gracefully.");

}

public void RequestStop()

{

_shouldStop = true;

}

// Voláteis, é usado como dica para o compilador que

//esse membro de dados será acessado por várias threads.

private volatile bool _shouldStop;

}

public class WorkerThreadExample

{

static void Main()

{

// Criar o objeto de discussão. Isso não iniciar a thread.

Worker workerObject = new Worker();

Thread workerThread = new Thread(workerObject.DoWork);

// Comece a thread.

workerThread.Start();

Console.WriteLine("main thread: Starting worker thread...");

// Repetir até thread ser ativa.

while (!workerThread.IsAlive);

// Coloque o fio condutor para dormir durante 1 milissegundo

//para permitir que o segmento de trabalho para fazer alguns trabalhos:

Thread.Sleep(1);

// Solicite que a thread pare:

workerObject.RequestStop();

// Use o método de associação para bloquear a thread

//atual até que a thread termine.

workerThread.Join();

Console.WriteLine("main thread: W ted.");

}

}

Bibliografia

Sites:

www.ufba.br

www.joaoseixas.blogspot.com

www.fortium.com.br

http://msdn.microsoft.com/pt-br/library/7a2f3ay4.aspx

Kernel

Curso:Tecnólogo em Análise e Desenvolvimento de Sistemas 4° Semestre

Deusdete de Oliveira Junior

Rodrigo Santi

 

O que é o Kernel

Trata-se de uma série de arquivos desenvolvidos na linguagem C e em Assembly que formam o núcleo do Sistema Operacional. Esses arquivos são responsáveis pelo controle do hardware presente em sua máquina.A tarefa principal do kernel é permitir que todos os processos seja executados pela CPU e permitir que eles consigam compartilhar a memória do computador.Tudo o que está abaixo da interface de chamadas do sistema e acima do hardware físico é o Kernel.

ref.: http://www.infowester.com/linuxkernel.php

Tipos de Kernel

Kernel Monolítico

`

A principal característica do Kernel monolítico é permitir que funções como rede, vídeo e acesso a outros periféricos sejam possíveis através do Kernel-space. Isso é possível através do uso de módulos. O que significa que um módulo, apesar de não estar no mesmo código do Kernel, é executado no espaço de memória do Kernel. Sendo assim, apesar de modular, o Kernel monolítico continua sendo único e centralizado.

Kernel Monolítico

ref.:http://localdomain.wordpress.com/2007/07/22/micro-kernel-ou-kernel-monolitico/

Micro-Kernel

É um método que estrutura o sistema operacional removendo todos os componentes que não são essenciais para o Kernel e implementando-os como programas de sistema e de nível de usuário deixando o Kernel menor. Com essa diminuição, tem-se como ganho a facilidade de expandir o sistema operacional.

Todos os novos serviços são inseridos no espaço do usuário o que não exige a modificação do Kernel.Quando, ainda sim as alterações são necessárias, elas são menores pois o Kernel é menor.

O Micro-Kernel não só é menor como é mais seguro e confiável pois a m aioria dos processos estão sendo executados como processos de usuários ao invés do Kernel. Caso haja alguma falha, o sistema operacional não sofre modificações.

 

 

Kernel Linux

O Kernel do Linux foi idealizado pelo Finlandês Linus Torvalds, no ano de 1991. Torvalds era estudante de ciência da computação. Em seus estudos teve de criar uma nova versão do Minix (sistema operacional baseado no Unix desenvolvido por Andy Tannenbaum).

Linus começou a trabalhar e, ao obter algo concreto enviou uma mensagem para um grupo de usuários do Minix na UseNet. Em sua mensagem, Linus notificou a todos e disse que disponibilizaria o código-fonte do seu desenvolvimento a todos os interessados.

A vontade de Linus era construir um sistema operacional no qual fosse possível de ser alterado conforme a necessidade.Ao criar a nova versão do Minix, Linus desenvolveu um método de utilizar o hardware do computador por software deixando livre, a cada interessado, adicionar aplicativos e funcionalidades desejadas para constituir o sistema operacional.

Versões do Kernel

Periodicamente, novas versões do kernel do Linux são lançadas. Isso ocorre para prover melhorias em uma determinada função da versão anterior, para corrigir vulnerabilidades e para adicionar recursos ao kernel, principalmente compatibilidade com novos hardwares.

Cada versão do kernel é representada por 3 números distintos separados por pontos, sendo que um quarto número pode ser aplicado, por exemplo: 2.6.21.3. O primeiro número indica a versão do kernel. Note que esse número muda raramente: a última alteração (até o fechamento do artigo referente) ocorreu em 1996, quando o kernel passou da versão 1 para a versão 2. O segundo número indica a última revisão feita até o momento naquela versão do kernel. O terceiro número, por sua vez, indica uma revisão menor, como se fosse uma "revisão da última revisão" do kernel. Note que o terceiro número pode ser acompanhado de pequenas siglas. Uma que costuma aparecer com freqüência é a sigla "rc" (release candidate), que indica a disponibilização de uma versão ainda não oficial, por exemplo: 2.6.22-rc1. Há siglas que apontam uma versão trabalhada por um desenvolvedor em específico, como a "mm", que indica as alterações feitas por Andrew Morton.

Como um quarto número pode ser usado, ele é aplicado quando uma falha grave no kernel for descoberta, sendo, portanto, necessário atualizá-lo. Porém, não faz sentido lançar uma revisão completa apenas por causa de algumas correções, razão esta que levou à utilização de um quarto número.

Não é necessário usar sempre a última versão do kernel. Só é recomendável fazer uma atualização em caso de necessidade de compatibilidade com novo hardware ou em casos de melhorias de recursos. Em alguns casos, principalmente com computadores antigos, o desempenho é melhor se usado um kernel antigo. Em situações simples, talvez seja melhor apenas aplicar um patch (uma correção para um problema) do que adicionar um kernel novo.

Compatibilidade

O kernel do Linux permite que o sistema operacional seja compatível com uma série de plataformas, desde palmtops até mainframes. Até mesmo nos computadores da Apple é possível instalar o Linux. As principais plataformas compatíveis são: Apple, Sun, Sparc, Alpha, PowerPC, i386 (Intel), ARM, entre outras.

Também existe compatibilidade com sistemas de arquivos. Apesar de não ser recomendável por questões de desempenho, é possível instalar o Linux até mesmo em partições FAT32. As principais compatibilidades neste aspecto são com os seguintes sistemas de arquivos: FAT, FAT32, ext2, ext3, ReiserFS, JFS, XFS, NTFS, entre outros.

Atuação do Kernel

O Kernel começa a atuar no processo de inicialização do sistema a partidas das instruções lidas na MBR (Master Boot Record - Recurso responsável por indicar a BIOS como e onde carregar o Sistema Operacional). Após essa etapa, o kernel começa a detectar os dispositivos de hardware essenciais do computador. Se tudo ocorrer bem nesta faze, a imagem do kernel passa a ser carregada. Em seguida, o kernel checa a memória e prepara para o uso através de uma função de paginação. Os IRQs, os discos, memória-cache, entre outros são acionados logo após esta função. Ao Final de todas estas etapas o sistema operacional esta pronto para funcionar.

O kernel carrega as funções responsáveis por checar o que deve ser inicializado em nível de software e processos, como, por exemplo, o conteúdo do arquivo /etc/init. Geralmente o que é carregado é a tela de login do usuário.

Usuário logado, sistema operacional trabalhando o kernel agora executa suas funções, como a de controlar o uso da memória pelos programas ou a de atender a chamada de uma interrupção de hardware.

É interessante notar que as distribuições Linux montam o kernel com recursos e drivers básicos para hardware, afinal carregar o suporte a todo tipo de dispositivo é algo inviável. O kernel ficaria extremamente grande e somente os drivers relacionados ao hardware do computador em questão é que seriam usados. Para lidar com esse tipo de problema, os drivers são carregados como módulos após o kernel ser ativado. A questão é que carregar recursos por módulo gera uma queda de desempenho (pouco significativa em computadores rápidos) e, por isso, muitos usuários preferem recompilar o kernel de seus sistemas para que esse carregue os drivers junto com sua inicialização, ou seja, sem usar módulos.

ref.: http://www.infowester.com/linuxkernel.php

O KERNEL do WINDOWS

O KERNEL, é importantíssimo para o bom desempenho do nosso Sistema Operativo, pois todos os programas dependem dele. Uma simples falha no mesmo, é o suficiente para provocar uma rotura em todos os outros programas ou contribuir para a perda de performance do nosso computador.

Quem é que nunca ouviu falar dos célebres “Ecrans azuis” (Blue Screen of Death), muito provavelmente todos nós. Para quem não sabe o responsável por este tipo de erros é o nosso “amigo” KERNEL, os ditos “Ecrans Azuis”, são o resultado de uma falha interna do mesmo ou então são o resultado de uma falha num driver associado ao processo, este tipo de erro é tão grave que o sistema operativo não consegue recuperar normalmente, sendo necessário proceder muitas vezes á recuperação do Windows através do CD de instalação, isto nos casos menos graves, pois outros há em que a resolução não é tão simples.

No Windows Vista, a Microsoft tenta minimizar este tipo de erros, salvaguardando a integridade do processo, ao mesmo tempo que tenta controlar o software instalado e o tipo de processos que são executados pelo mesmo. Há a tentativa de “isolar” todo este processo, ao contrário do que era feito até agora, nomeadamente no XP e 2003.

O KERNEL, é um dos primeiros processos a arrancar, quando o Windows se inicia, é ele que permite ao software “falar” com o Hardware, assim como é o responsável por tarefas tão básicas, como a gestão da memória, o lançamento de processos, o arranque dos programas e a gestão dos dados armazenados no nosso disco rígido. A performance, o rendimento e a segurança do nosso computador, dependem da integridade do KERNEL, dai a importância do mesmo.

Provavelmente, já ouviram falar em “Rootkit”, os quais são muito difíceis de remover e difíceis de detectar, temos sempre de recorrer a software de terceiros para o fazer… e por vezes acabamos por optar pelo método mais radical, a formatação do nosso disco rígido e a consequente reinstalação do Windows. Sem darmos por isso, os Rootkits, tentam ganhar aceso ao KERNEL e consequentemente o poder de controlar todas as outras aplicações do nosso computador (para evitar este tipo de situações convêm instalar um bom anti-malware, que consiga detectar rootkit).

Este tipo de “peste” é muito perigosa e tem como finalidade ganhar acesso aos ficheiros fundamentais do nosso sistema operativo Windows, monitorizando KeysStrokes, alterando logs de ficheiros, alterando aplicações do sistema, criando Backdoors no nosso sistema que permitam ganhar acesso remoto ao nosso computador e possibilitar ataques externos. Esta “peste”, tem também a “habilidade” de se esconder dos ficheiros de sistema, de algumas ferramentas anti-pestes e claro dos utilizadores… que muitas vezes só dão por ela, tarde demais.

Ao longo do tempo tem existido a tentativa de alterar o código base do KERNEL, por parte dos criadores de programas de Spyware/Malware/Vírus, com a única intenção de “esconder” os seus processos do utilizador, este tipo de alteração ao código, dá origem muitas vezes a erros no sistema operativo e á consequente falha de certos programas… não é por acaso que o nosso computador, quando está infectado por maleitas deste tipo, fica muito lento.

Para terminar, gostaria de relembrar que é deveras importante, instalar um Antivírus, um AntiSpyware/Malware e fundamentalmente mantê-los actualizados, assim como instalar os updates mais recentes do Windows. Se conseguirmos manter o nosso sistema operativo protegido, ficaremos menos sujeitos a este tipo de ataques e consequentemente o desempenho do nosso computador será muito superior.

ao mesmo tempo que outros tem um primeiro contacto com um dos processos fundamentais do Windows, existem outros como o HAL (Hardware Abstraction Layer ) que tem como “missão” carregar os drivers necessários ao bom funcionamento de todo o Hardware instalado no nosso computador.

 

Funcionamento do Kernel

Software para Gerenciamento de Processos no Windows

Seguem alguns links para o download de softwares (free e opensource) para gerenciamento de processos nos sistema operacionais MS-Windows.

Process Monitor 2.6
http://www.softpedia.com/get/System/System-Info/Microsoft-Process-Monitor.shtml

Process Manager For Windows 1.6.192
http://terrabrasil.softonic.com/ie/79043/Process_Manager_For_Windows
http://technet.microsoft.com/en-us/sysinternals/bb896645.aspx

Process Explorer v11.33
http://technet.microsoft.com/en-us/sysinternals/bb896653.aspx

Mais links sobre gerenciamento de processos:

http://www.lgti.ufsc.br/posgraduacao/legenda/gpa/Processo_Cochabamba.pdf

http://www.patentesonline.com.br/gerenciamento-de-sistemas-de-computador-e-aplicacoes-distribuidas-baseado-em-modelo-34499.html

http://www.patentesonline.com.br/processos-de-operar-um-computador-e-de-proteger-informacoes-armazenadas-em-uma-memoria-108537.html

Gerenciamento de Processos Linux e Windows

Curso:Tecnólogo em Análise e Desenvolvimento de Sistemas 4° Semestre

Marco Antonio Batista Barbosa

Valdeci dos Santos

PROCESSO:

Um processo nada mais que um programa em execução, incluindo os valores correntes de todos os registradores do hardware, e das variáveis, manipuladas por ele no curso de sua execução Informalmente, dizemos que um processo e um programa em execução.

Gerenciamento de Processos no Linux Passo a Passo

Há duas maneiras de realizar o gerenciamento de processos no Linux:

Forma gráfica;

Através de uma janela terminal;

Forma gráfica:

Selecionar a seguinte sequência:

Iniciar - Aplicativos - Sistemas - Monitor de Sistema

Após a sequência será aberta a seguinte janela:

Na janela acima, pode-se verificar os processos os execução, o quanto de memória está sendo alocada para cada processo, utilização da CPU, além de poder ser realizado um filtro, para visualização de processos apenas de programas , processos de sistema , processos de usuários, ou visualizar todos os processos . Há também a opção de se "matar" o processo, marcando o processo na lista, e selecionando a opção "matar processo".

Através da janela de terminal:

Selecionar a seguinte sequência:

Iniciar - Aplicativos - Sistemas - Terminal

Após a sequência será aberta a seguinte janela:

Através da tela de terminal, podemos executar o comando PS (Procces Status), e verificar os vários processos que estão em execução na máquina .
Uma boa dica para quem quer adquirir um conhecimento maior sobre um determinado comando no Linux, e utilizar o help do comandos, através do comando "man", abreviação de manual . Por exemplo para se obter a descrição completa do comando ps, basta digitar no prompt $ man ps (figura abaixo):




Para verificar todos os processos em execução no Linux, o comando a ser digitado é o "ps -e" .

Com este comando é mostrado o PID (Procces Identifier) de cada processo, e com isto podemos encerrar o processo ao executarmos o comando Kill .
Exemplo: $ kill 760 (caso houvesse um processo com o PID 760)



GERENCIAMENTO DE PROCESSO NO WINDOWS

A única forma de gerenciamento de processos no windows, é através da ferramenta gráfica "Gerenciador de Tarefas", o qual é aberto após pressionar as teclas CTRL + ALT + DELETE.

Na aba de processos, visualizamos todos os processos em execução, bem como a utilização de CPU e memória utilizada .
Na aba de rendimento, pode-se verificar a utilização da CPU, e de memória, e assim identificar se a máquina está lenta por falta de memória, ou por um alta utilização da CPU (figura abaixo)

Para quem quiser baixar um video com uma explicação e o passo a passo do gerenciamento de arquivos no Linux (forma gráfica e via terminal), basta acessar o endereço abaixo e baixar o video .

http://www.4shared.com/file/129918072/6ab75181/Gerenciamento_Processos_Linuxpart1.html