Temos TIPOS DE PROCESSOS, que são:
Processos Ativos: são aqueles processos que estao sendo executados, processos que estao rodando e recebendo ou enviando dados.
Processos em primeiro plano, que são chamados de foreground. Esses processos bloqueiam o terminal quando estao sendo executados, porque ele mostra um resultado visivel daquele processo que esta rodando.
Processos em segundo Plano, que são chamados de Background. São os processos que estao rodando em um terminal que esta livre, onde assim, ele não bloqueia o meu terminal atual.
Os processos que estao rodando na minha maquina, podem estar em foreground ou background.
Processos inativos: são processos que estao sem atividade por algum motivo.
Processos Parados: são aqueles que estao sem atividade, mas que podem voltar a rodar atraves de comandos.
Processos Zumbis: são raros de acontecer, mas podem ser processos que estavam ativos mas que pararam a muito tempo de enviar/receber dados, ou que simplesmente não respondem. Esses processos podem tanto estar travados, como simplesmente estar parado por não ter nenhum dado para processar.
Iniciando Processos
Para iniciar um processo, basta digitar um comando executavel para que ele torne-se um processo.
Basicamente, os processos são sempre inicializados por outros processos. E o primeiro processo executado é chamado de processo pai. Os seguintes processos, que são gerados a partir desses processos pais, são chamados de Processos Filhos.
Um exemplo para entender melhor: Quando eu quero acessar uma máquina remotamente, eu faço um acesso SSH. E depois que acessei inicio algum programa dentro dessa máquina. O acesso em si é um processo Pai, e o programa que está aberto dentro da máquina é um processo filho.
Para ver esses processos que temos na máquina, usamos alguns comandos. Mas temos também o diretório /proc que é o responsável por informações de kernel e de processos também.
#ls /proc
Esses números que estão representando as pastas, são também processos que temos rodando em nosso sistema. Se vocês verem o conteúdo dessas pastas, será o mesmo conteúdo, mas cada pasta está se referindo a algum programa diferente, onde dentro dela tenho módulos que fazem parte da inicialização e execução desses processos. Se quiser saber qual serviço determinada pasta está representando, basta filtrar os processos que estão rodando no nosso sistema.
Lembrando que algumas informações, somente o root poderá saber.
Temos o comando pstree. Para executar é:
#pstree
Esse comando mostra uma espécie de árvore dos processos que são executados quando você inicia o Linux.
Existe também o comando:
#pstree -p
Esse comando mostra números na frente de casa nome da árvore. Esses número são chamados de PID, que são um código de identificação que cada processo recebe enquanto está sendo executado. ID – identidade/identificação
Para ver mais processos que estão rodando na minha máquina, posso usar o comando ps:
#ps
Esse comando mostrará qual tty estou usando para executar esse comando e que estou logado. tty é a representação do nosso terminal, do shell que estamos logados.
**pts é o dispositivo para terminal em ambiente gráfico
Para ter uma informação mais completa sobre os processos que estou rodando no meu sistema, uso o comando ps -f:
#ps -f
Agora, para ver TODOS os processos que estão rodando, uso o comando ps aux:
#ps aux
Esse comando mostra os processos correntes no meu sistema.
Se quero ver processos de algum usuário específico, posso usar o comando:
#ps -u user
ou
#ps aux | grep user
Esse dois comandos mostram os processos do usuário que você solicitou, mas mostram resultados de uma maneira um pouco diferente.
Uma estrutura que é interessante saber é a do comando ps aux, porque quando você executa ele, além de mostrar os processos que estão rodando, ele mostra uma série de informações. Por exemplo:
#ps aux
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
user 4694 0.0 5.9 33700 13372 ? S 11:45 0:00 kded [kdeinit] --new-startup
user 4699 0.0 0.1 1584 296 ? S 11:45 0:00 kwrapper ksmserver
user 4701 0.0 3.9 26084 8964 ? S 11:45 0:00 ksmserver [kdeinit]
user 4702 0.1 5.1 28084 11676 ? S 11:45 0:04 kwin [kdeinit] -session
user 4704 0.0 7.4 32852 16764 ? S 11:45 0:01 kdesktop [kdeinit]
user 4706 0.9 6.7 33672 15108 ? S 11:45 0:35 kicker [kdeinit]
A primeira linha mostra o seguinte: USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
Cada nome dele é representado por uma coluna e cada um tem uma função diferente, explicando:
USER: é o nome do usuário que executou o processo.
PID: (Process Identifier) é o número que indica o processo
%CPU: o valor em porcentagem que o processo está usando de CPU
%MEM: o valor em porcentagem de quanto o processo está usando de memória
VSZ: mostra o tamanho virtual do processo, onde é quando indica que a memória RAM está sendo insuficiente para aquele processo, então ele começa a usar a memória virtual que é a swap.
RSS: (Resident Set Size) é a quantidade usada de memória em KB.
TTY: é o identificador de terminal, onde ele mostra em qual terminal está rodando aquele processom, quando tem ? quer dizer que não depende de nenhum terminal em específico
STAT: O stat é o status do processo, que é representado pelas letras R, S, Z, D, T
START: Horário em que o processo começou
TIME: Tempo de CPU que o processo está consumindo enquanto estiver rodando
COMMAND: nome do comando que executa aquele processo
No STAT, temos as linhas que indicam como está o status do processo. Quando um processo está com STAT:
R – (Running) é um processo executável, que está em execução
S – (Sleep) é um processo que está suspenso, aguardando algum recurso
Z – (Zombie) é um processo zumbi, onde é um processo que já morreu, mas que ainda está consumindo memória
D – Em espera do disco, onde está aguardando uma requisição
T – (Traced) é um processo que foi interrompido
Algumas vezes, quando usamos o comando ps aux, conseguimos ver o path de alguns programas. Path é o Caminho de um arquivo. Onde o programa está instalado. E esse caminho sempre está representado na última coluna de resposta do comando psaux.
TOP
O top também serve para visualizar processos que estão rodando no Linux, mas em tempo real. Ele também mostra PID, informações de memória, quanto está sendo usado, quanto está livre e assim por diante.
Processos em Background: quando falamos em processos em background, estamos falando de processos que estão rodando em segundo plano. Todo processo que você executa em um terminal, roda em foreground, ou seja, roda em primeiro plano. E dependendo do que eu quero fazer, meu terminal torna-se indisponível para outras tarefas. Por exemplo, quando executo o comando top para ver os processos em tempo real, se eu quiser ver/executar alguma outra coisa, meu terminal estará bloqueado, porque o top estará rodando nele. Nesse caso, eu tenho um processo rodando em primeiro plano que está travando meu terminal. Agora se eu quisesse mandar essa tarefa para um segundo plano, para que ele libere meu terminal, mas não deixe de executar o que eu pedi, eu mando para background. Para fazer isos, basta colocar o & (e-comercial) na frente. Por exemplo:
#top &
Ele colocará o processo em segundo plano, e para voltar:
#fg 1
Ele mostrará a resposta do que você enviou para o background.
Outro exemplo:
#man ls
CTRL + Z
Ele irá parar o processo e colocar em background. Depois:
#fg 1
Ele voltará o man que estava parado para foreground.
Agora, se eu fizer assim:
#top &
#man ls
Enviarei dois processos para background. Eles recebem uma numeração conforme os processos que enviei para lá. Para saber a numeração e quantos processos tenho em background, uso o comando:
#jobs -l
Ele listará tudo o que está em background e seus respectivos PIDs.
O comando nice, configura a prioridade de um comando.
Cada comando tem prioridade. Por exemplo o PID do init é 1, ou seja, é uma das primeiras coisas que sobe quando o nosso sistema operacional é iniciado. Quando determino que um comando vai ter prioridade, é quando estou separando o que é mais importante, tem que ter mais atenção, ou seja, será iniciado primeiro, e o que é menos importante terá menos prioridade, ou seja, será iniciado depois e assim por diante, é a mesma coisa quando damos prioridades para as nosssas tarefas do dia-a-dia, primeiro vem o dever e depois a diversão!! Então, poderíamos classificar a prioridade do dever, como uma prioridade -20, que é uma prioridade mais alta e a prioridade da diversão, com uma prioridade 19, que é a prioridade mais baixa. As prioridades são referenciadas como prioridades maiores por número negativos, prioridades menores, por números positivos.
Para configurarmos a prioridade de um processo, usamos o comando nice.
Por exemplo:
#nice -n -19 find / -name apropos
outra coisa interressante todos os programas iniciam com prioridade 10 e os usuarios comum não podem setar prioridade negativa.
O comando nice é usado geralmente para coisas como por exemplo, você tem um player de mp3 rodando e ele as vezes fica parando ou engasga enquanto você está navegando em algumas páginas, para isso, você poderá mudar a prioridade desse programa, para que não aconteça mais esse tipo de coisa, com o comando:
#nice -n -20 mp3player
O sistema dará prioridade máxima para o seu programa de mp3. E isso não fará com que trave ou que aconteça coisas do tipo enquanto estiver executando outros programas.
Agora, para usao o comando nice, meu programa de mp3 tem que estar parado, ou seja, ele não pode estar em execução. Mas se eu quiser mudar a prioridade do meu mp3 com ele rodando, uso o comando renice. Então não quero fechar meu programa mas quero mudar a prioridade dele, mesmo com ele rodando, faço assim:
#renice -n -20 -p PID
Ou seja, com esse comando, estou indicando que quero mudar a prioridade do meu processo, o número da prioridade e o PID dessa prioridade. Então para saber o PID dos processos que estão rodando na máquina, usarei o comando top ou o ps aux.
Por exemplo, vou abrir um programa para editar uma imagem, chamado gimp, ams vou abrir ele em background, então ficaria assim:
#gimp &
E depois que o programa está aberto, vou visualizar o PID dele. Então:
ps aux | grep gimp
Ele mostrará o PID e os processos que foram gerados quando abri o gimp. Então aparecerá assim:
root 5423 13.9 9.8 27436 22180 pts/1 S 10:39 0:01 gimp
root 5424 1.5 1.9 12840 4380 pts/1 S 10:39 0:00 /usr/lib/gimp/2.0/plug-ins/script-fu -gimp 6 5 -run 0
root 5426 0.0 0.3 1944 736 pts/1 S+ 10:39 0:00 grep gimp
Agora, quero mudar a prioridade desse programa, sem ter que fechar ele, então, como já sei o PID, somente executo o comando para mudar a prioridade.
#renice -n -19 -p 5423
Ele mudará a prioridade sem alterar nada e nem fechar o programa.
Agora, imagine que estou com o Gimp aberto, não mudei a prioridade dele, mas ele travou!! Como não consigo nem tentar abrir ele, para tentar fechar justamente pelo fato de estar travado, então posso “matar” o processo que o gimp está gerando, porque assim não ficarei com um programa parado em minha máquina e poderei fechar ele para não ficar consumindo memória. Para isso, uso o comando kill. Para usar esse comando, tenho que saber também o PID do processo. Por exemplo, como eu já sei que o gimp está rodando no meu sistema, eu não preciso pedir para ele listar todo o conteúdo do ps aux somente para ver o PID do arquivo, por exemplo ps aux | grep gimp, eu uso o comando pgrep. Então ficaria assim:
#pgrep gimp
5423
Ele mostrará direto o PID do processo gimp. E agora, você já poderá “matar” esse processo. Então você faria assim:
#kill 5423
Ele matará o processo. E automaticamente fechará o programa que estava travado.
Agora, se eu mato diretamente esse processo, sem parâmetros, ele as vezes pode perguntar se quero mesmo matar esse processo e etc. E por padrão, se uso o comando kill sem parâmetros, então ele usa o parâmetro -15, seria a mesma coisa que se eu digitasse kill 5423 ou kill -15 5423. Mas se tenho certeza que quero matar e não quero perguntas, então eu uso o comando kill -9 PID
Temos vários sinais para usar com o comando kill. Por exemplo:
Se uso kill -1 PID, suspendo o processo. Se uso kill -2 Interrompo o processo. Se uso kill -3 abandono o processo. Kill -9 Destrói o processo. kill -11 erros de endereço de memória (falha de segmentação) kill -15 encerra. Todos os sinais, independentemente de qual você use, ele ENCERRA o programa que vocês está executando.