Ubuntu ps, pgrep, top

Todo programa aberto no seu Ubuntu vira um ou mais processos. Nesta aula você vai listar esses processos, encontrar um pelo nome e entender os casos em que o terminal "não acha nada", mesmo com o programa aberto na sua frente.

Você vai aprender

O que é um processo e o que é um PID.
Por que ps sozinho mostra só dois processos.
Como ler cada coluna do ps aux.
Por que pgrep chromium não encontra o Chromium, e como descobrir o nome certo.
Como acompanhar tudo ao vivo com top e htop.

O que é um processo

Um programa é um arquivo parado no disco, como /usr/bin/nautilus. Quando você o abre, o sistema carrega esse arquivo na memória e começa a executá-lo. Essa execução é um processo.

Cada processo recebe um número único, o PID (process ID, "identificador do processo").
Cada processo tem um dono: o usuário que o iniciou.
Um programa pode virar vários processos. O Chromium, por exemplo, cria um processo para a janela principal e outros para as abas.
Cada processo tem um nome curto, que nem sempre é o nome que aparece no menu de aplicativos. Isso vai ser importante daqui a pouco.

Nos exemplos, a máquina fictícia notebook está com o Chromium, o app Arquivos (Nautilus) e o Editor de Texto abertos.

ps: a foto dos processos

ps vem de process status, "situação dos processos". Ele tira uma foto do momento: mostra a lista e termina.

ps: O programa, sem nenhuma opção.

$ ps
    PID TTY          TIME CMD
   3001 pts/0    00:00:00 bash          « o shell deste terminal
   3100 pts/0    00:00:00 ps            « o próprio ps

Por que só aparecem dois processos?

O Chromium está aberto, mas não apareceu. Isso não é erro: ps sem opções mostra só os processos do terminal em que você está. Neste terminal só existem o bash (o programa que lê o que você digita) e o próprio ps.

Coluna	Exemplo	Significado
`PID`	`3001`	O número do processo.
`TTY`	`pts/0`	O terminal ao qual o processo pertence. `pts/0` é a primeira janela de terminal aberta; outra janela seria `pts/1`.
`TIME`	`00:00:00`	Tempo de processador que o processo já usou (não é há quanto tempo ele está aberto).
`CMD`	`bash`	O nome do processo.

Programas abertos pelo menu, como o Chromium, não pertencem a nenhum terminal. Para vê-los, você precisa pedir ao ps que mostre todos.

ps aux: todos os processos

ps: O programa.
a: Processos de todos os usuários (não só os seus) que tenham terminal.
u: Formato voltado ao usuário: mostra dono, CPU, memória e horário.
x: Inclui os processos sem terminal, como os apps abertos pelo menu.

Sem hífen?

O ps aceita dois estilos de opção: o estilo BSD, sem hífen (ps aux), e o estilo Unix, com hífen (ps -ef). Os dois funcionam no Ubuntu. ps aux é o mais usado.

$ ps aux
USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1  26960 17868 ?        Ss   08:00   0:04 /sbin/init splash
root         812  0.0  0.2 342104 21480 ?        Ssl  08:00   0:01 /usr/sbin/NetworkManager --no-daemon
ana         1534  3.1  4.2 5012344 662140 ?      Ssl  08:01   2:15 /usr/bin/gnome-shell
ana         2210  5.4  6.8 55665664 1093120 ?    Sl   08:05   4:36 /snap/chromium/3554/usr/lib/chromium-browser/chrome --password-store
ana         2251  2.0  3.9 54541540 629004 ?     Sl   08:05   1:02 /snap/chromium/3554/usr/lib/chromium-browser/chrome --type=renderer
ana         2304  0.1  1.5 1252104 245100 ?      Sl   08:06   0:03 /usr/bin/nautilus --gapplication-service
ana         2388  0.0  1.1 988204 181400 ?       Sl   08:10   0:01 /usr/bin/gnome-text-editor
ana         3001  0.0  0.1  12104  5640 pts/0    Ss   08:12   0:00 bash
ana         3105  0.0  0.0  13900  4420 pts/0    R+   10:30   0:00 ps aux

Num computador de verdade essa lista tem centenas de linhas; aqui ela foi encurtada. Repare que a última coluna mostra o comando completo que iniciou o processo, e não só o nome.

Cada coluna do ps aux

Coluna	Exemplo	Significado
`USER`	`ana`	Dono do processo. `root` é o administrador.
`PID`	`2210`	Número do processo. É ele que você usa no kill.
`%CPU`	`5.4`	Quanto do processador ele usa, em média. Acima de 100 significa mais de um núcleo.
`%MEM`	`6.8`	Quanto da memória RAM ele ocupa.
`VSZ`	`55665664`	Memória virtual reservada, em KB. Costuma ser enorme e não indica uso real.
`RSS`	`1093120`	Memória realmente ocupada na RAM, em KB (1093120 KB ≈ 1 GB). É a que importa.
`TTY`	`?`	Terminal do processo. `?` = não pertence a nenhum terminal.
`STAT`	`Sl`	Estado: `R` rodando, `S` dormindo (esperando algo), `D` esperando disco, `Z` zumbi, `T` parado. Letras extras: `s` líder de sessão, `l` várias threads, `+` em primeiro plano.
`START`	`08:05`	Horário em que o processo começou.
`TIME`	`4:36`	Tempo total de CPU já usado (minutos:segundos).
`COMMAND`	`/snap/chromium/…/chrome`	Comando completo, com caminho e argumentos.

Olhe o caminho do Chromium

O Chromium do Ubuntu é instalado como snap, por isso mora em /snap/chromium/…. E o arquivo que roda se chama chrome, não chromium. Guarde esse detalhe.

Outras formas de listar

Comando	O que mostra
`ps aux`	Todos os processos, formato com CPU e memória.
`ps -ef`	Todos os processos, formato com `PPID` (o processo "pai").
`ps aux --sort=-%cpu \| head`	Os que mais usam processador primeiro. O `-` antes de `%cpu` inverte a ordem.
`ps aux --sort=-%mem \| head`	Os que mais usam memória primeiro.
`ps -C chrome`	Só os processos com o nome exato `chrome`.
`ps -u ana`	Só os processos da usuária ana.
`ps -eo pid,comm,%mem --sort=-%mem`	Só as colunas que você escolher.

$ ps -eo pid,comm,%mem --sort=-%mem | head -4
    PID COMMAND         %MEM
   2210 chrome           6.8
   1534 gnome-shell      4.2
   2251 chrome           3.9

pgrep: achar um processo pelo nome

pgrep junta process com grep (a ferramenta de busca do Linux): ele procura processos pelo nome e mostra os PIDs.

pgrep: O programa: procura processos.
-l: De list: mostra o nome ao lado do PID.
chrome: O texto a procurar no nome do processo.

$ pgrep -l chrome
2210 chrome
2251 chrome

Dois resultados: a janela principal e o processo de uma aba. Sem o -l, o pgrep mostraria só os números.

O caso real: "pgrep chromium não mostra nada"

Um leitor deste guia, com o Chromium aberto, tentou várias vezes:

$ pgrep chromium
$ pgrep -l chromium
$ pgrep -l Chromium
$ pgrep -l Chrome
$ pgrep firefox
$

Nenhuma resposta. O terminal não deu erro e não mostrou nada. Para saber o que aconteceu, olhe o código de saída:

$ pgrep chromium
$ echo $?
1                                            « 1 = nenhum processo encontrado

Código	Significado no pgrep
`0`	Achou pelo menos um processo.
`1`	Não achou nenhum. Não é um erro do comando: é a resposta "não existe".
`2`	Erro de uso, como uma opção errada.

Por que não achou nada? São três motivos diferentes:

O pgrep procura no nome do processo, não no nome do aplicativo. O app se chama "Chromium", mas o processo se chama chrome. Como "chromium" não aparece dentro de "chrome", nada bate.
Maiúsculas importam. Chromium e Chrome, com C maiúsculo, nunca batem com chrome. Use -i para ignorar maiúsculas.
O Firefox simplesmente não estava aberto. Aí o certo é mesmo não aparecer nada.

Repare que pgrep -l chrom funcionaria, porque "chrom" está dentro de "chrome". O pgrep procura um pedaço do nome, não o nome inteiro.

Procurar na linha de comando inteira: `-f`

Com -f (de full, "completo"), o pgrep procura no comando completo, aquele da coluna COMMAND do ps aux. Como o caminho tem /snap/chromium/, agora a palavra "chromium" é encontrada.

pgrep: O programa.
-a: De all: mostra a linha de comando completa de cada resultado.
-f: Procura no comando completo, não só no nome.
chromium: O texto procurado.

$ pgrep -af chromium
2210 /snap/chromium/3554/usr/lib/chromium-browser/chrome --password-store
2251 /snap/chromium/3554/usr/lib/chromium-browser/chrome --type=renderer
$ pgrep -il CHROME
2210 chrome
2251 chrome

Cuidado com o -f

Com -f, qualquer processo que tenha a palavra em algum lugar do comando aparece, inclusive outros programas que abriram um arquivo com esse nome. Antes de usar o mesmo padrão para encerrar processos com pkill -f, confira a lista com pgrep -af.

O nome do processo tem no máximo 15 caracteres

O Linux guarda só os 15 primeiros caracteres do nome. O Editor de Texto roda o arquivo gnome-text-editor, mas o nome do processo fica cortado:

$ pgrep -l gnome
1534 gnome-shell
2388 gnome-text-edit                         « cortado em 15 caracteres
$ pgrep gnome-text-editor
pgrep: o padrão que pesquisa por nomes de processo maiores que 15 caracteres vai resultar em zero correspondências
Tente a opção "pgrep -f" para corresponder com a linha de comando completa.
$ pgrep -fl gnome-text-editor
2388 gnome-text-edit

Aqui o próprio pgrep avisa: um padrão com mais de 15 caracteres nunca vai bater com o nome, e ele sugere o -f. Com -f, a busca vai no comando completo (/usr/bin/gnome-text-editor) e funciona.

Missão 1: reproduza o problema. Rode pgrep chromium e depois echo $?. Em seguida, descubra os PIDs do navegador com pgrep -l chrome e confirme com pgrep -af chromium.

Descobrir o nome real de um processo

Quando você não sabe como o processo se chama, há várias formas de descobrir:

Forma 1: `ps aux` filtrado com `grep`

$ ps aux | grep -i chrom
ana   2210  5.4  6.8 55665664 1093120 ?  Sl   08:05   4:36 /snap/chromium/3554/usr/lib/chromium-browser/chrome --password-store
ana   2251  2.0  3.9 54541540 629004 ?   Sl   08:05   1:02 /snap/chromium/3554/usr/lib/chromium-browser/chrome --type=renderer
ana   3120  0.0  0.0   6720  2764 pts/0  S+   10:31   0:00 grep -i chrom      « o próprio grep!

A última linha é o próprio grep procurando "chrom": ele também é um processo e tem "chrom" no comando. É normal. Para escondê-lo, use colchetes no padrão: ps aux | grep -i '[c]hrom'. O padrão continua achando "chrom", mas o texto do comando do grep passa a ser "[c]hrom", que não bate consigo mesmo.

Forma 2: `pgrep -af`

Mais curto e sem a linha do grep: pgrep -af chrom. É a forma recomendada.

Forma 3: `pidof`

pidof ("PID de") recebe o nome exato e devolve os PIDs numa linha só:

$ pidof chrome
2251 2210
$ pidof chromium
$ echo $?
1

Forma 4: ao vivo, no `top` ou no `htop`

Veja a seção seguinte. No htop, pressione F4 e digite parte do nome.

Forma 5: pela interface gráfica

Abra o app Recursos (o monitor do sistema do Ubuntu 26.04) e use a aba de aplicativos ou de processos. Ele mostra o nome amigável e o nome do processo.

Forma	Comando	Melhor quando…
pgrep com -af	`pgrep -af chrom`	Você sabe parte do nome ou do caminho. Primeira opção.
ps + grep	`ps aux \| grep -i '[c]hrom'`	Você quer ver também CPU, memória e dono.
pidof	`pidof chrome`	Você já sabe o nome exato.
htop	`F4` + nome	Você quer acompanhar ao vivo.
App Recursos	menu de aplicativos	Você prefere a interface gráfica.

top: os processos ao vivo

O ps é uma foto; o top é um vídeo. Ele atualiza a tela a cada 3 segundos e coloca no topo quem mais usa o processador. Para sair, pressione q.

$ top
top - 10:32:17 up  2:31,  1 user,  load average: 0,61, 0,71, 0,74
Tarefas: 312 total,   1 em exec., 311 dormindo,   0 parado,   0 zumbi
%CPU(s):  4,8 us,  1,3 sy,  0,0 ni, 93,5 id,  0,2 wa,  0,0 hi,  0,0 si,  0,0 st
MB mem :  15374,2 total,   3755,2 free,   4700,1 used,   7371,0 buff/cache
MB swap:   4096,0 total,   4096,0 free,      0,0 used.  10674,1 avail mem

    PID USUARIO   PR  NI    VIRT    RES    SHR S  %CPU  %MEM    TEMPO+ COMANDO
   2210 ana       20   0   53,1g   1,0g 182144 S  12,0   6,8   4:36.12 chrome
   1534 ana       20   0 4894,9m 646,6m 120332 S   6,3   4,2   2:15.40 gnome-shell
   2251 ana       20   0   52,0g 614,3m 101220 S   2,1   3,9   1:02.08 chrome
   3130 ana       20   0   10876   6096   3984 R   0,3   0,0   0:00.02 top

Linha do topo	O que diz
`up 2:31`	A máquina está ligada há 2 horas e 31 minutos.
`load average`	Carga média em 1, 5 e 15 minutos. Comparada ao número de núcleos: abaixo dele, tudo tranquilo.
`Tarefas`	Total de processos e quantos estão rodando, dormindo, parados ou zumbis.
`%CPU(s)`	`us` programas, `sy` sistema, `id` ocioso, `wa` esperando disco.
`MB mem`	Memória total, livre, usada e em cache. O número que importa é `avail mem` (disponível).

Mistura de idiomas

Repare que o top do Ubuntu em português traduz só parte da tela ("Tarefas", "USUARIO", "COMANDO") e usa vírgula nos decimais.

Teclas do top

Tecla	O que faz
`q`	Sai do top.
`P`	Ordena por CPU (padrão).
`M`	Ordena por memória.
`k`	Encerra um processo: pede o PID e o sinal.
`u`	Mostra só os processos de um usuário.
`o`	Filtro. Ex.: digite `COMMAND=chrome`.
`1`	Mostra cada núcleo do processador separado.
`c`	Alterna entre o nome e o comando completo.

htop: o top mais amigável

O htop tem cores, barras de uso e funciona com o mouse. Ele não vem instalado:

$ htop
Comando 'htop' não encontrado, mas poder ser instalado com:
sudo snap install htop  # version 3.5.3, or
sudo apt  install htop  # version 3.4.1-5build2
Veja 'snap info htop' para versões adicionais.
$ sudo apt install htop

A mensagem "mas poder ser instalado" tem um erro de digitação que vem da própria tradução do Ubuntu. Prefira instalar pelo apt.

Tecla no htop	O que faz
`F3` ou `/`	Busca um processo pelo nome (pula até ele).
`F4` ou `\`	Filtra: mostra só os processos com aquele texto.
`F5`	Mostra em árvore (quem é pai de quem).
`F6`	Escolhe a coluna de ordenação.
`F9`	Encerra o processo selecionado.
`F10` ou `q`	Sai.

Memória e carga: `free` e `uptime`

Quando o computador fica lento, estes dois comandos dão o panorama em uma linha:

$ free -h
               total       usada       livre    compart.  buff/cache   disponível
Mem.:           15Gi       4,6Gi       3,7Gi       118Mi       7,2Gi         10Gi
Swap:          4,0Gi          0B       4,0Gi
$ uptime
 10:32:40 up  2:31,  1 user,  load average: 0,61, 0,71, 0,74

Em free, olhe a coluna disponível: é quanta memória os programas ainda podem usar. "livre" parece pouco porque o Linux usa a memória sobrando como cache, e devolve quando alguém precisa. O -h mostra os números em Gi e Mi.

Missão 2: descubra qual processo usa mais memória na máquina fictícia. Rode ps aux e compare a coluna %MEM. Depois confira a memória total com free.

Quando não funciona

O pgrep não mostra nada

$ pgrep Spotify
$ echo $?
1

O que aconteceu: nenhum processo tem "Spotify" no nome. Pode ser maiúscula errada, nome diferente do aplicativo ou o programa realmente fechado.

Como resolver: tente pgrep -il spot (sem maiúsculas e com só um pedaço do nome). Se ainda não achar, use pgrep -af spot para procurar no comando completo.

O ps não mostra o programa que está aberto

$ ps
    PID TTY          TIME CMD
   3001 pts/0    00:00:00 bash
   3140 pts/0    00:00:00 ps

O que aconteceu: sem opções, o ps mostra só o terminal atual.

Como resolver: use ps aux, de preferência filtrado: ps aux | grep -i nome.

O grep aparece no meio do resultado

O que aconteceu: em ps aux | grep firefox, a única linha encontrada é a do próprio grep firefox. Isso indica que o Firefox não está rodando.

Como resolver: use pgrep -af firefox, que não lista a si mesmo, ou grep '[f]irefox'.

O PID mudou

O que aconteceu: você anotou o PID 2210 ontem e hoje ele é outro. Cada vez que um programa é aberto, recebe um PID novo.

Como resolver: procure de novo com pgrep antes de usar o número.

Referência de opções

pgrep

Opção	Descrição	Exemplo
`-l`	Mostra o nome junto do PID	`pgrep -l chrome`
`-a`	Mostra a linha de comando completa	`pgrep -a chrome`
`-f`	Procura no comando completo, não só no nome	`pgrep -f chromium`
`-i`	Ignora maiúsculas e minúsculas	`pgrep -i CHROME`
`-x`	Nome exato, não um pedaço	`pgrep -x chrome`
`-u`	Só processos de um usuário	`pgrep -u root -l`
`-c`	Mostra só a quantidade	`pgrep -c chrome`
`-n` / `-o`	Só o mais novo / o mais antigo	`pgrep -n chrome`

ps

Forma	Descrição
`ps`	Processos do terminal atual
`ps aux`	Todos, com CPU, memória e dono
`ps -ef`	Todos, com o PID do processo pai
`ps -C nome`	Pelo nome exato
`ps -u usuário`	De um usuário
`ps -p PID`	Um processo específico
`--sort=-%cpu`	Ordena (o `-` inverte)
`-o pid,comm,%mem`	Escolhe as colunas
`--forest`	Desenha a árvore de pais e filhos

Exercícios

1. Ver todos os processos

Complete para listar os processos de todos os usuários, inclusive os que não têm terminal:

2. Procurar no comando completo

O processo se chama chrome, mas você só lembra da palavra "chromium". Complete:

pgrep chromium

3. Ignorar maiúsculas

Complete para que CHROME encontre o processo chrome:

pgrep CHROME

4. Você rodou pgrep firefox e nada apareceu. echo $? mostrou 1. O que isso significa?

O pgrep travou. Nenhum processo com "firefox" no nome foi encontrado. Você não tem permissão para ver os processos. O Firefox está aberto, mas em outro terminal.

5. No ps aux, qual coluna mostra a memória que o processo realmente ocupa?

VSZ TIME STAT RSS

Resumo

ps sozinho mostra só o terminal atual; ps aux mostra tudo.
pgrep nome procura um pedaço do nome do processo, que pode ser diferente do nome do aplicativo (Chromium → chrome).
-f procura no comando completo, -i ignora maiúsculas, -a mostra o comando, -l mostra o nome.
Sem resultado, o pgrep fica em silêncio e devolve o código 1: confira com echo $?.
top e htop mostram tudo ao vivo; q sai.
Próximo passo: encerrar processos com kill.