Alterar prioridade de processos com nice e renice no Linux

Os comandos nice e renice são usados para ajustar a prioridade de processos no Linux. Isso é especialmente útil para gerenciar o uso de CPU em sistemas onde múltiplos processos competem por recursos, ajudando a garantir que processos mais importantes tenham prioridade maior.

O que são nice e renice?

Comando nice

Define a prioridade de um processo no momento em que ele é iniciado. O “nível de niceness” (valor de nice) indica o quão “agradável” o processo será em relação aos outros:

• Valores altos tornam o processo menos prioritário.
• Valores baixos tornam o processo mais prioritário.

Comando renice

O comando renice permite alterar a prioridade de processos que já estão em execução.

Sintaxe básica

nice:

$ nice -n <valor> comando

renice:

$ renice <valor> -p <PID>

Intervalo de valores de nice

Os valores de “niceness” podem variar de -20 a 19:

• -20: Maior prioridade.
• 0: Prioridade padrão (valor padrão para a maioria dos processos).
• 19: Menor prioridade.

Processos com valores de nice menores recebem mais tempo de CPU em relação a processos com valores maiores – ou seja, tem maior prioridade.

Como verificar a prioridade de um processo?

Podemos usar os comandos ps, top ou htop para verificar o valor de nice de processos:

1. Com ps:

   $ ps -eo pid,ni,cmd

   A coluna NI mostra o valor de nice.

2. Com top:

   $ top

   Localize a coluna NI para ver os valores de nice.

3. Com htop:

   O htop também exibe a coluna de nice de forma interativa.

Exemplos do comando nice

Exemplo 1: Executar um processo com prioridade baixa

$ nice -n 10 tar -czf backup.tar.gz /home/fabio

Este comando cria um arquivo backup.tar.gz, mas com prioridade menor (nice = 10), consumindo assim menos recursos do sistema caso o processo demore (por exemplo, se a pasta tiver milhares de arquivos).

Exemplo 2: Executar um processo com prioridade alta (menos “agradável”)

Para usar valores de nice menores que 0, é necessário ser superusuário:

$ sudo nice -n -5 dd if=/dev/zero of=/dev/null

Neste exemplo, o comando copia um fluxo infinito de bytes zero (/dev/zero) para o “buraco negro” (/dev/null). Ele é executado com prioridade -5, o que significa que receberá mais tempo de CPU em relação a processos com prioridades padrão ou mais baixas.

Execute o comando em um terminal, e abra outra aba ou terminal para verificar o processo em execução. Use os comandos top ou htop para visualizar o processo gerado pelo comando dd, e perceba o valor de nice (coluna NI) que o processo está usando – no caso, será -5.

Para encerrar o dd. pressione Ctrl+C na aba onde ele está em execução.

Obs.:
/dev/zero: dispositivo especial do sistema que fornece um fluxo infinito de bytes zero.
/dev/null: dispositivo especial do sistema que descarta tudo que é escrito nele (“buraco negro”).

Exemplos do comando renice

Exemplo 1: Alterar a prioridade de um processo em execução

1. Execute novamente o comando do exemplo anterior encontre o PID do processo (usando outra aba do terminal):

   $ sudo nice -n -5 dd if=/dev/zero of=/dev/null 
   $ ps aux | grep dd

2. Verifique sua prioridade atual e a altere, por exemplo para 10:

   $ top
   $ renice 10 -p <PID retornado anteriormente> 
   $ top

   Desta forma, o valor de nice do processo será alterado para 10, tornando o processo menos prioritário.

Exemplo 2: Alterar a prioridade de todos os processos de um usuário

$ sudo renice -n 10 -u fabio

Com este comando todos os processos do usuário fabio terão sua prioridade ajustada para 10.

A seguir temos alguns exercícios para você treinar mais o emprego dos comandos nice e renice para alterar prioridades de execução de processos no Linux.

Exercícios práticos

1. Execute um comando simples, como sleep, com um valor de nice igual a 15.
2. Use renice para alterar a prioridade do processo sleep em execução.
3. Liste todos os processos em execução e encontre os valores de nice associados a eles.
4. Crie um script que execute três comandos simultaneamente com diferentes valores de nice e os compare com ps.
5. Altere a prioridade de todos os processos de um usuário específico, por exemplo o usuário mariana,  para um valor de nice igual a 12.

Resolução dos exercícios

1. Execute o comando sleep com nice igual a 15

$ nice -n 15 sleep 100

Este comando executa o sleep com prioridade baixa.

2. Use renice para alterar a prioridade de um processo

1. Encontre o PID do processo (use outra aba ou janela de terminal):

   $ ps aux | grep sleep

2. Altere sua prioridade:

   $ sudo renice 5 -p <PID>

3. Liste todos os processos e seus valores de nice

$ ps -eo pid,ni,cmd

4. Criar um script para comparar diferentes valores de nice

#!/bin/bash

echo "Iniciar processos com diferentes prioridades..."
nice -n 0 dd if=/dev/zero of=/dev/null &
nice -n 10 dd if=/dev/zero of=/dev/null &
nice -n 19 dd if=/dev/zero of=/dev/null &
ps -eo pid,ni,cmd | grep dd

Salve o arquivo como teste_nice.sh, e o torne executável:

$ chmod +x teste_nice.sh

Execute o script para testar:

./teste_nice.sh

Para encerrar os processos no terminal podemos executar o comando kill -9 seguido do pid de cada um:

$ kill -9 <pid>

5. Altere a prioridade de todos os processos de um usuário qualquer

sudo renice -n 12 -u mariana

Conclusão

Os comandos nice e renice são ferramentas importantes para ajustar a prioridade de processos no Linux, permitindo que possamos controlar como os recursos da CPU são alocados.

Isso é especialmente útil em servidores e ambientes com carga alta, onde a gestão adequada de processos pode melhorar o desempenho do sistema.