Süreç Önceliği Yönetimi: nice ve renice Kullanımı

yazar

Sistem yöneticiliğinde en çok göz ardı edilen konulardan biri süreç önceliklendirmesidir. Sunucunda aynı anda onlarca, hatta yüzlerce süreç çalışırken hangisinin CPU zamanından daha fazla pay alacağını belirlemek, sistem performansını doğrudan etkiler. İşte tam bu noktada nice ve renice komutları devreye girer. Bu yazıda bu iki komutun nasıl çalıştığını, ne zaman kullanman gerektiğini ve gerçek dünya senaryolarında nasıl işe yaradığını derinlemesine ele alacağız.

Süreç Önceliği Nedir?

Linux çekirdeği, CPU kaynaklarını süreçler arasında dağıtmak için bir zamanlayıcı (scheduler) kullanır. Bu zamanlayıcı her sürece belirli bir CPU zamanı dilimi tahsis eder. Ancak tüm süreçler eşit değildir, bazılarının diğerlerinden daha önce işlem görmesi gerekebilir.

Nice değeri bu önceliği temsil eden bir sayıdır. Linux’ta nice değeri -20 ile +19 arasında değişir:

  • -20: En yüksek öncelik (süreç CPU’dan en fazla payı alır)
  • 0: Varsayılan değer (yeni başlatılan süreçlerin nice değeri)
  • +19: En düşük öncelik (süreç CPU’dan en az payı alır)

Burada mantık biraz kafa karıştırıcı gelebilir: Nice değeri düştükçe öncelik artar. Yani -20’deki bir süreç, +19’daki bir sürece göre CPU’ya çok daha hızlı erişir. “Nice” kelimesini şöyle düşün: Bir süreç ne kadar “nazik” (nice) ise diğer süreçlere o kadar çok yer açar, yani o kadar az öncelikli olur.

Normal kullanıcılar yalnızca 0 ile +19 arasında değer atayabilir. Negatif değerler yalnızca root yetkisi gerektirir. Bu önemli bir güvenlik mekanizmasıdır, çünkü aksi hâlde herhangi bir kullanıcı kendi sürecinin önceliğini artırarak sistem kaynaklarını ele geçirebilir.

nice Komutu: Süreci Başlatırken Öncelik Belirlemek

nice komutu, bir süreci belirli bir nice değeriyle başlatmak için kullanılır. Eğer hâlihazırda çalışan bir süreci değiştirmek istiyorsan, birazdan anlatacağım renice komutunu kullanman gerekir.

Temel Kullanım

nice [seçenek] [komut]

Herhangi bir parametre vermeden nice çalıştırırsan, mevcut shell’in nice değerini gösterir:

nice

Çıktı genellikle 0 olacaktır.

Bir komutu varsayılan +10 nice değeriyle çalıştırmak için:

nice komut

Özel bir nice değeri belirtmek için -n parametresini kullanırsın:

nice -n 10 tar -czf yedek.tar.gz /home/kullanici/

Bu komut, tar işlemini +10 nice değeriyle başlatır. Yani yedek alma işlemi sistem kaynaklarından daha az pay alır ve diğer kritik süreçler aksatılmaz.

Root olarak negatif değer atamak:

sudo nice -n -5 /usr/bin/critical-service

Pratik Örnekler

Büyük bir dosyayı kopyalarken sistemin yavaşlamasını istemiyorsan:

nice -n 15 cp -r /var/data/buyuk-dizin /backup/

Python ile uzun süren bir veri analizi scriptini arka planda düşük öncelikle çalıştırmak:

nice -n 19 python3 veri_analizi.py &

Buradaki & işareti süreci arka plana atar. nice -n 19 ise ona sistemdeki en düşük önceliği verir. Script çalışırken diğer kullanıcılar veya servisler hiçbir performans kaybı yaşamaz.

Bir find komutu çalıştırırken:

nice -n 18 find / -name "*.log" -mtime +30 -delete

30 günden eski log dosyalarını temizleyen bu komut, özellikle production sunucularda düşük öncelikle çalıştırılmalıdır.

renice Komutu: Çalışan Süreci Anında Değiştirmek

renice komutu çok daha güçlü ve pratik bir araçtır. Hâlihazırda çalışan bir sürecin nice değerini anında değiştirebilirsin. Bunu yapmak için sürecin PID’ini (Process ID) bilmen gerekir.

Temel Kullanım

renice -n [değer] -p [PID]

ya da kısaca:

renice [değer] [PID]

Önce hangi süreci değiştireceğini bulmak için ps veya top kullanabilirsin:

ps aux | grep mysqld

Diyelim ki MySQL’in PID’i 1842 olarak geldi. Bunu düşük önceliğe almak için:

renice -n 10 -p 1842

Ya da aynı işlemi eski sözdizimi ile:

renice 10 1842

Kullanıcıya Göre Tüm Süreçleri Değiştirmek

renice yalnızca tek bir PID ile çalışmaz. Bir kullanıcıya ait tüm süreçlerin önceliğini aynı anda değiştirebilirsin:

renice -n 5 -u ahmet

Bu komut, ahmet kullanıcısına ait tüm çalışan süreçlerin nice değerini +5 yapar. Örneğin bir kullanıcı sistemi aşırı kullanıyorsa bu yöntemle müdahale edebilirsin.

Bir grup için de aynı işlemi yapabilirsin:

renice -n 5 -g gelistiriciler

Bu komut gelistiriciler grubuna ait tüm süreçleri etkiler.

Root Olarak Öncelik Artırma

Normal kullanıcılar nice değerini yalnızca artırabilir (önceliği düşürür), ancak bir kez düşürdükten sonra tekrar yükseltemezler. Root ise her iki yönde de değişiklik yapabilir.

Diyelim ki önemli bir backup süreci yavaş çalışıyor ve önceliğini artırmak istiyorsun:

sudo renice -n -10 -p 2847

Bu komut söz konusu süreci daha yüksek öncelikli yapar. Tabii bunu yaparken dikkatli olmalısın çünkü yanlış bir sürecin önceliğini çok yüksek yaparsak sistemi kilitleyebilirsin.

top ile Anlık Öncelik Yönetimi

top komutunu kullanıyorken nice değerlerini interaktif olarak da değiştirebilirsin. Bu yöntem özellikle hangi süreçlerin yavaş çalıştığını görsel olarak takip etmek istediğinde çok kullanışlıdır.

top çalışırken:

  • r tuşuna bas
  • Değiştirmek istediğin sürecin PID’ini gir
  • Yeni nice değerini gir

htop kullanıyorsan çok daha kolay: Süreci ok tuşlarıyla seçip F7 (önceliği artır) veya F8 (önceliği düşür) tuşlarını kullanabilirsin.

Gerçek Dünya Senaryoları

Senaryo 1: Production’da Yedek Alma

Bir production web sunucusunda gece 02:00’da yedek alma işlemi başlatıyorsun. Ancak sunucunuzda 7/24 çalışan bir API servisi var ve bu servisin yavaşlaması kabul edilemez.

#!/bin/bash
# yedek_al.sh

echo "Yedek alma başlıyor: $(date)"

nice -n 15 tar -czf /backup/site_$(date +%Y%m%d).tar.gz /var/www/html/

nice -n 15 mysqldump -u root -p'sifre' --all-databases | 
    gzip > /backup/mysql_$(date +%Y%m%d).sql.gz

echo "Yedek tamamlandı: $(date)"

Bu script’te hem tar hem de mysqldump işlemleri +15 nice değeriyle çalışır. API servisi normal öncelikte (0) çalışmaya devam eder ve yedek alma işleminden etkilenmez.

Senaryo 2: Sunucuda Kontrolden Çıkan Bir Süreç

Bir kullanıcı yanlışlıkla CPU’yu %95 kullanan bir süreç başlattı ve sistemi neredeyse kilitledi. Bağlantın hâlâ varken hızlıca müdahale etmen gerekiyor:

# Önce sorunu tespit et
ps aux --sort=-%cpu | head -10

# CPU'yu en çok kullanan süreci bul (diyelim PID 4521)
# Hemen önceliğini düşür
sudo renice -n 19 -p 4521

# Durumu kontrol et
ps -p 4521 -o pid,ni,comm

Bu sayede süreci öldürmeden (kill etmeden) sistemi rahatlatmış olursun. Kullanıcıya da sürecinin neden yavaşladığını açıklayabilirsin.

Senaryo 3: Çoklu İş Parçacıklı Derleme

Büyük bir yazılım projesini derlerken tüm CPU çekirdeklerini kullanmak ama sistemin kullanılabilirliğini de korumak istiyorsun:

# make komutunu tüm çekirdekleri kullanarak ama düşük öncelikle çalıştır
nice -n 15 make -j$(nproc)

$(nproc) komutu sistemdeki çekirdek sayısını otomatik alır. nice -n 15 ise derlemenin diğer işleri etkilememesini sağlar. Derleme belki biraz daha uzun sürer ama sunucu boyunca kullanılabilir kalır.

Senaryo 4: Log Analizi Scripti

Geceleri çalışan büyük log analiz scriptlerini düşük öncelikle çalıştırmak yaygın bir iyi pratiktir:

#!/bin/bash
# log_analiz.sh - Her gece cron ile çalışır

# Scriptin kendi nice değerini ayarla
renice -n 18 -p $$

# Şimdi tüm alt işlemler de bu önceliği miras alır
grep "ERROR" /var/log/app/*.log | awk '{print $1}' | sort | uniq -c > /tmp/error_rapor.txt
grep "CRITICAL" /var/log/app/*.log >> /tmp/error_rapor.txt

# Raporu mail ile gönder
mail -s "Günlük Log Raporu" [email protected] < /tmp/error_rapor.txt

$$ özel değişkeni mevcut script’in PID’ini içerir. Bu şekilde script başladıktan hemen sonra kendi önceliğini ayarlayabilir.

Senaryo 5: Birden Fazla Süreci Aynı Anda Yönetmek

Sistemde çalışan tüm Python süreçlerini bul ve önceliğini düşür:

# Python süreçlerinin PID'lerini bul ve renice uygula
pgrep -x python3 | xargs -I {} sudo renice -n 10 -p {}

# Veya daha kısa yol
for pid in $(pgrep python3); do
    sudo renice -n 10 -p $pid
    echo "PID $pid için nice değeri 10 yapıldı"
done

nice Değerini Kontrol Etme

Bir sürecin mevcut nice değerini görmek için birkaç yöntem var:

# ps ile belirli bir süreci kontrol et
ps -p 1842 -o pid,ni,comm,cmd

# Tüm süreçlerin nice değerlerini listele
ps -eo pid,ni,comm --sort=ni

# Belirli bir kullanıcının süreçleri
ps -u ahmet -o pid,ni,comm

ps çıktısında NI sütunu nice değerini, PRI sütunu ise gerçek önceliği gösterir. PRI değeri genellikle 20 + NI formülüyle hesaplanır (farklı sistemlerde değişebilir).

/proc Üzerinden Nice Değeri

Daha derinlemesine bir inceleme için /proc dosya sistemini de kullanabilirsin:

# PID 1842'nin öncelik bilgisini göster
cat /proc/1842/status | grep -i nice

# Ya da
cat /proc/1842/stat | awk '{print "Nice:", $19}'

Bu yöntem özellikle script yazarken faydalıdır çünkü başka araçlara bağımlı olmadan nice değerini okuyabilirsin.

Cron ile Kullanım

Cron işlerini otomatik olarak düşük öncelikle çalıştırmak için iki yöntem var:

Yöntem 1: Crontab içinde nice kullan

# crontab -e ile düzenle
0 2 * * * nice -n 15 /usr/local/bin/yedek_al.sh

Yöntem 2: Script başında renice kullan

#!/bin/bash
renice -n 15 -p $$ > /dev/null 2>&1
# geri kalan script...

İkinci yöntem daha esnektir çünkü script’in kendisi önceliğini kontrol eder, onu çağıran sistem buna göre hazırlık yapmak zorunda kalmaz.

ionice ile Birlikte Kullanmak

nice sadece CPU önceliğini etkiler. Disk I/O yoğun işlemler için ionice komutunu da bilmen gerekir. İkisini birlikte kullanmak en iyi sonucu verir:

# Hem CPU hem de disk I/O önceliğini düşür
ionice -c 3 nice -n 19 rsync -av /kaynak/ /hedef/

ionice -c 3 süreci “idle” I/O sınıfına koyar. Yani disk başka bir iş yapmıyorsa çalışır. nice -n 19 ise CPU’yu en az kullanan mod. Bu kombinasyon yedekleme ve veri transferi işlemleri için mükemmeldir.

# Büyük dosya kopyalamak için ideal ayar
sudo ionice -c 2 -n 7 nice -n 15 cp -r /data/buyuk-klasor /backup/

Systemd Servislerinde Öncelik Ayarı

Eğer systemd ile yönetilen bir servis yazıyorsan, nice değerini servis dosyasında kalıcı olarak belirtebilirsin:

[Service]
Type=simple
ExecStart=/usr/local/bin/benim_scriptim.sh
Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=7

Bu yaklaşım çok daha temiz ve yönetilebilirdir. Servis her yeniden başladığında nice değeri otomatik uygulanır, el ile müdahale gerekmez.

Dikkat Edilmesi Gereken Noktalar

Öncelik kalıtımı: Bir süreç başka bir süreç başlatırsa (fork), child süreç parent’ın nice değerini miras alır. Yani nice -n 15 bash dersen, o bash’tan çalıştırdığın tüm komutlar da +15 nice değeriyle başlar.

Değer sınırları: Normal kullanıcılar nice değerini yalnızca 0’dan büyük yapabilir. Bir kez artırdıktan sonra tekrar düşüremezler. Root bu kısıtlamaya tabi değildir.

Etki alanı: Nice değeri gerçek zamanlı (real-time) süreçleri etkilemez. SCHED_FIFO veya SCHED_RR zamanlama politikasına sahip süreçler nice değerinden bağımsız çalışır.

Çok çekirdekli sistemler: Modern sistemlerde nice değeri tek başına yeterli olmayabilir. CPU pinning ve cgroup’lar daha ince kontrole izin verir. Ancak basit senaryolar için nice/renice her zaman yeterlidir.

Performans yanılgısı: Nice değerini düşürmek (önceliği artırmak) süreci sihirli bir şekilde hızlandırmaz. Eğer sistem zaten boşta çalışıyorsa önceliğin hiçbir etkisi yoktur. Öncelik yalnızca çekişme (contention) durumunda anlamlıdır.

Sonuç

nice ve renice komutları, Linux sistem yöneticisinin toolbox’ında her zaman bulunması gereken araçlardandır. Yedek alma scriptleri, log analizi, büyük veri işlemleri ve derleme işleri gibi senaryolarda bu komutları kullanmak, production sistemlerinin sağlığını korumak açısından kritik öneme sahiptir.

Pratik özet olarak şunu söyleyebilirim: Eğer bir işlem uzun süre çalışacaksa ve acil değilse, nice -n 15 veya daha yüksek bir değerle başlatmaktan çekinme. Disk I/O da yoğunsa ionice -c 3 ile kombinle. Systemd servisi yazıyorsan Nice= direktifini servis dosyasına ekle ve bir daha düşünme. Çalışan bir süreci anında frenlemek gerekiyorsa renice -n 19 -p PID her zaman ilk başvuracağın komut olsun.

Bu iki komut sayesinde sunucunu hem verimli hem de dengeli bir şekilde çalıştırabilir, kritik servislerin aksamamasını garantileyebilirsin.

Yorum yapın