Linux-commando nice: prioriteit instellen, wijzigen met renice en het CPU-aandeel meten bij concurrentie

Affiliatemelding v3.1
Affiliatemelding v3.2 (mobiel)
TestomgevingRHEL-familieAlmaLinux 9.8root · gewoon gebruikersaccountGecontroleerd op 17-10-2026

Het Linux-commando nice stelt de nice-waarde van een programma in (-20 tot 19), die bepaalt hoeveel CPU het afstaat aan andere processen als het draait. Metingen op een AlmaLinux 9-server, met twee taken vastgezet op één CPU-core en de nice-waarde per run gewijzigd, lieten zien dat de CPU alleen werd verdeeld als de taken erom concurreerden, en de taak met nice 19 gebruikte maar 1,4%.

Processen die al draaien wijzig je met renice, en ionice regelt het voorrang geven aan de schijfkant. Bij alle drie de commando's staat de uitvoer precies zoals ze die als root en als gewone gebruiker gaven.

1️⃣ Linux-commando nice: waardebereik en het CPU-aandeel bij concurrentie

De nice-waarde is een getal dat bepaalt hoeveel een proces voorrang geeft als CPU-tijd wordt verdeeld, en je kunt hem instellen van -20 tot 19. Programma's draaien normaal op 0; -20 komt als eerste aan de beurt en 19 geeft het meest voorrang.

Je zou denken dat een hoger getal eerst aan de beurt komt, maar nice-waarden werken andersom. De Linux-scheduler geeft elke nice-waarde een gewicht en verdeelt de CPU-tijd in die verhouding: nice 0 is 1024, 10 is 110 en 19 is 15.

Voorrang geven gebeurt alleen als taken om de CPU concurreren. Is er een vrije CPU, dan draait zelfs een taak met nice 19 zonder te wachten. Het is zoals voorrangsplaatsen in de bus: als ze vrij zijn mag iedereen zitten, en je staat je plek alleen af als de bus vol is.

🧭 nice-waarden bij een vrije vs. drukke CPU
Uitlegdiagram
🖥️ CPU
⚖️ Taak B
🖥️ Er is een vrije CPU, dus elke taak krijgt een eigen core🖥️ Twee taken delen één CPU-core
Taak Anice 0 · gewicht 1024
100%50.0%90.3%98.6%
Taak Bnice 0 · gewicht 1024nice 10 · gewicht 110nice 19 · gewicht 15
100%50.0%9.7%1.4%
Met CPU over is er niemand om voorrang aan te geven, dus taak B gebruikt de CPU volledig, wat zijn nice-waarde ook is.
Concurreren ze om dezelfde core, dan verdelen twee taken met nice 0 en gelijk gewicht de CPU-tijd half-half.
nice 10 heeft een gewicht van 110, ongeveer een negende van nice 0 (1024), dus de CPU-tijd wordt ongeveer 90,3 : 9,7 verdeeld.
nice 19 heeft een gewicht van 15; bij concurrentie gebruikt taak B maar ongeveer 1,4% van de CPU-tijd.

De gewichtstabel is de array [sched_prio_to_weight] in de Linux-kernelbron [kernel/sched/core.c], en hij is zo ontworpen dat elke stap omhoog in de nice-waarde de CPU-tijd met ongeveer 10% verlaagt.

2️⃣ Basisgebruik van nice: +10 als het getal ontbreekt, en waarden buiten het bereik

Zet een commando achter nice en dat commando draait met een gewijzigde nice-waarde; typ nice alleen en het toont de nice-waarde van de huidige shell.

nice
0

In de voorbeelden hieronder toont de gestarte bash zijn eigen nice-waarde met [ps -o ni=]. Zonder -n wordt 10 bij de huidige waarde opgeteld; met -n 5 wordt 5 opgeteld.

nice bash -c 'ps -o ni= -p $$'
 10
nice -n 5 bash -c 'ps -o ni= -p $$'
  5

Waarden buiten het bereik worden zonder fout op de grens gezet, dus -n 50 draait op 19.

nice -n 50 bash -c 'ps -o ni= -p $$'
 19

Alleen root kan een proces met een negatieve waarde naar voren halen. Een gewone gebruiker krijgt de waarschuwing [cannot set niceness], en het commando draait toch op nice 0.

# als gewone gebruiker
nice -n -5 bash -c 'ps -o ni= -p $$'
nice: cannot set niceness: Permission denied
  0
# als root
nice -n -5 bash -c 'ps -o ni= -p $$'
 -5

Kindprocessen die een commando onder nice start, draaien ook met dezelfde nice-waarde.

nice -n 7 bash -c 'sleep 1 & ps -o ni= -p $!'
  7

Draai je een script met nice, dan geeft dus elk commando erin ook voorrang.

3️⃣ renice: de nice-waarde van een draaiend proces wijzigen

nice stelt de waarde alleen bij het starten in, dus voor een proces dat al draait gebruik je renice. Controleer eerst de PID en de huidige waarde in de NI-kolom van top of met ps.

ps -o pid,ni,cmd -p 201643
    PID  NI CMD
 201643   5 sleep 600
renice -n 10 -p 201643
201643 (process ID) old priority 5, new priority 10

Zoals de uitvoer laat zien, telt renice -n niet op bij de huidige waarde maar zet het de waarde die je opgeeft: het resultaat is 10, niet 5 + 10 = 15. Het is niet zoals op ▲ drukken op de afstandsbediening van een airco om één stap omhoog te gaan, maar zoals de doeltemperatuur op 24 graden zetten.

Ook de officiële documentatie van util-linux beschrijft -n als een absolute waarde; optellen doe je in nieuwere versies met de optie [--relative]. util-linux 2.37.4, de geteste versie, had deze optie niet.

Een gewone gebruiker kan de waarde van zijn eigen processen alleen verhogen en kan hem niet meer verlagen als hij eenmaal verhoogd is.

# als gewone gebruiker
renice -n 10 -p 201649
201649 (process ID) old priority 0, new priority 10
renice -n 5 -p 201649
renice: failed to set priority for 201649 (process ID): Permission denied

root kan hem ook verlagen; in dezelfde test veranderde 10 direct in 3.

🔲 Simulator voor nice · renice

In de simulator hieronder, ingelogd als gewone gebruiker, kun je nice en renice zelf typen en zien hoe de nice-waarde verandert.

Simulator van het nice-commandonice 8.32 · renice 2.37.4
[root@server work]#
Hij draait alleen in je browser en raakt nooit een echt proces. De virtuele server is ingelogd als gewone gebruiker: start iets met een gewijzigde nice-waarde, of wijzig de waarde van backup.sh (PID 2481) met renice, en controleer het dan met ps -o pid,ni,cmd. Met de toetsen ↑↓ haal je eerdere commando's terug.

4️⃣ Het CPU-aandeel bij concurrentie meten: nice 0 vs 0·10·19

Een hogere nice-waarde maakt een taak niet altijd trager. Zijn aandeel krimpt alleen als hij met een andere taak om dezelfde CPU concurreert.

Twee taken werden vastgezet op één CPU-core (taskset), en het script hieronder, dat 5 seconden lang telkens één getal optelt, draaide in beide tegelijk. Hoe hoger de telling, hoe meer CPU-tijd de taak gebruikte.

#!/bin/bash
end=$((SECONDS+5)); n=0
while [ $SECONDS -lt $end ]; do n=$((n+1)); done
echo $n

Het script verhoogt n met 1 tot er 5 seconden voorbij zijn en toont dan de eindwaarde.

📊5 seconden concurreren om één CPU-coreTelling in 5 seconden
Eerste taak nice 0Tweede taak
nice 0 vs nice 0
Twee taken met hetzelfde gewicht.
0250K500K750K1M
nice 0497.59648.8%
nice 0522.04051.2%
nice 0 vs nice 10
Alleen de tweede taak draait op nice 10.
0250K500K750K1M
nice 0979.97190.1%
nice 10107.6719.9%
nice 0 vs nice 19
Alleen de tweede taak draait op nice 19.
0250K500K750K1M
nice 0909.89598.6%
nice 1913.0101.4%
Cijfers van een AlmaLinux 9-server op 17 oktober 2026, met de twee taken vastgezet op één CPU-core en elk 5 seconden tegelijk gedraaid.

Twee taken met nice 0 verdeelden het half-half, terwijl nice 10 ongeveer 10% gebruikte en nice 19 maar 1,4%. Dit klopt met de verhoudingen berekend uit de kernelgewichten (1024 : 110 geeft 90,3 : 9,7, en 1024 : 15 geeft 98,6 : 1,4).

Alleen op dezelfde core telde de taak met nice 19 in 5 seconden ongeveer 650.000 tot 1.140.000 keer. Zonder iemand om voorrang aan te geven gebruikt zelfs nice 19 de CPU volledig; de serverbelasting (load average) was tijdens de test 3 tot 5.

5️⃣ ionice: voorrang geven bij schijf-I/O en de scheduler controleren

nice bepaalt alleen het CPU-aandeel, dus geef bij taken die lang van de schijf lezen en erop schrijven, zoals back-ups, met ionice ook voorrang in de schijfvolgorde. Met -c3 (idle) wordt een taak alleen bediend als geen ander programma de schijf gebruikt.

ionice -c3 bash -c 'ionice -p $$'
idle
ionice -p $$
none: prio 0

Een proces zonder ingestelde klasse wordt getoond als [none]; volgens de kerneldocumentatie wordt het behandeld als best-effort, met een prioriteit die uit de CPU-nice-waarde wordt berekend.

ionice-klassen werken alleen als de schijfscheduler ze ondersteunt, en de kerneldocumentatie noemt bfq en mq-deadline als ondersteunende schedulers. De scheduler tussen vierkante haken is degene die nu in gebruik is.

cat /sys/block/nvme0n1/queue/scheduler
[none] mq-deadline kyber bfq

De NVMe-schijf op de testserver gebruikt [none], dus volgens de officiële documentatie heeft ionice daar mogelijk geen effect; het effect is niet apart gemeten. Controleer de schijfnaam met lsblk.

6️⃣ Waar je nice gebruikt: back-ups · cron · wp-cli

Zet nice voor taken die lang duren maar niet dringend zijn. Back-upcompressie gebruikt zowel CPU als schijf, dus stel nice en ionice samen in.

nice -n 19 ionice -c3 tar czf backup.tgz /home/example

Maakt een taak die al draait de server trager, zoek dan de PID op in top en verhoog de waarde met renice; zet bij cronjobs die elke dag draaien nice vóór het commando.

0 3 * * * nice -n 10 /usr/local/bin/backup.sh

Draai je op een WordPress-server grote wp-cli-taken zoals search-replace of het opnieuw genereren van afbeeldingen met nice -n 10, dan krijgt php-fpm, dat bezoekersverzoeken afhandelt, als eerste de CPU als die druk is.

nice -n 10 wp media regenerate --yes

Verhoog daarentegen niet de nice-waarde van php-fpm of van de webserver zelf. Als de processen die bezoekers antwoorden voorrang geven, reageren pagina's trager als de CPU druk is.

🔢 FAQ & aanbevolen content

Voor normale processen toont top PR als 20 plus de nice-waarde. Een proces gestart met nice 5 toonde PR 25 en NI 5, terwijl de kolom PRI in ps anders rekent en hetzelfde proces als 14 toonde.

nice telt de opgegeven waarde op bij de huidige nice-waarde. [nice -n 5 nice -n 3 nice] toont 8, anders dan renice -n, dat de waarde zet op wat je opgeeft.

Zet [Nice=] in de sectie [Service] van het unitbestand van de service, en dat stelt de nice-waarde in van de processen die de service draait. Volgens de officiële documentatie van systemd.exec kan dat van -20 tot 19.

🧭 Processen en taakplanning: aanbevolen inhoud 11 berichten · 4 bronnen
🗂️ Processen en taakplanning
📄 ps-commando 📄 top-commando 📄 Linux-commando nice 📄 kill-commando 📄 killall-commando 📄 Achtergrond & voorgrond 📄 uptime-commando
📄 crontab instellen
📋 WP CLI: installatie en instelling 📄 WP-Cron(wp-cron.php) 📄 Gesynchroniseerde patronen vinden: WP-CLI
📡 GNU Coreutils nice invocation 📡 renice(1) Linux manual page 📡 Block io priorities (kerneldocumentatie) 📡 sched_prio_to_weight (kernelbron)

ℹ️ Affiliatemelding
De content van deze site bevat affiliatelinks. Koopt een bezoeker via een van deze links een product of dienst, dan ontvangt deze site een commissie van de verkoper. Het bedrag dat de koper betaalt (bij acties gaat het omlaag ↓) wordt daardoor niet hoger. De vermelde prijzen, kortingen en voorraad gelden op het moment van schrijven en kunnen afwijken; controleer ze daarom vóór je aankoop bij de verkoper. Producten worden gekozen en beoordeeld volgens onze eigen criteria, en commissies hebben geen invloed op de volgorde of de inhoud van de beoordelingen.

Geef een reactie

Je e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

Laat zien dat je geen machine bent: 9   +   2   =