[NODE JS] process.nextTick ve setImmediate Farki

Silverhand · 13 Tem 2026

[NODE JS] process.nextTick ve setImmediate Farki

Herkese merhaba, bugun Node.js'e ozgu iki onemli fonksiyonu karsilastiracagiz: process.nextTick ve setImmediate. Bu ikisi ilk bakista ayni isi yapiyor gibi gorunse de calisma sralari ve kullanim alanlari farklidir. Isimleri de kafa karistirici cunku nextTick aslinda "hemen" calisir, immediate ise "sonra" calisir. Ben de ilk basta bu isimleri yanlis anlamistim, isimler aldatici.

Temel Fark

process.nextTick, mevcut islem tamamlandiktan hemen sonra, Event Loop'un bir sonraki fazina gecmeden once calisir. Yani microtask kuyrugunda islenip hemen calistirilir. setImmediate ise Event Loop'un check fazinda, yani mevcut poll fazindan sonra calisir. Pratikte bu demek oluyor ki nextTick her zaman immediate'den once calisir.

Bir analoji verelim: nextTick, bir konusmacinin "bir saniye, bunu da eklleyeyim" deyip hemen ek yapmasidir. setImmediate ise "bir sonraki konusmaci" demektir. nextTick suanki sirayi uzatir, setImmediate yeni bir sira baslatir.

JavaScript:

// nextTick vs setImmediate temel karsilastirma
console.log('=== Temel Karsilastirma ===\n');

setImmediate(() => {
    console.log('3. setImmediate');
});

process.nextTick(() => {
    console.log('1. nextTick (her zaman once!)');
});

Promise.resolve().then(() => {
    console.log('2. Promise (nextTick'ten sonra, immediate'den once)');
});

console.log('0. Senkron kod');

// Cikti sirasi:
// 0. Senkron kod
// 1. nextTick
// 2. Promise
// 3. setImmediate

// I/O callback icinde davranis
const fs = require('fs');

fs.readFile(__filename, () => {
    // I/O callback icinde sira HER ZAMAN:
    // nextTick -> Promise -> setImmediate -> setTimeout

    process.nextTick(() => {
        console.log('\n[I/O icinde] nextTick');
    });

    setImmediate(() => {
        console.log('[I/O icinde] setImmediate');
    });

    setTimeout(() => {
        console.log('[I/O icinde] setTimeout');
    }, 0);

    Promise.resolve().then(() => {
        console.log('[I/O icinde] Promise');
    });
});

Ne Zaman Hangisini Kullanmali?

nextTick genelde su durumlarda kullanilir: bir event emit etmeden once listener'larin baglanmasi icin zaman tanima, bir fonksiyonun her zaman asenkron davranmasini garanti etme ve hata yayilimini kontrol etme. setImmediate ise CPU-yogun islemleri parcalara ayirmak ve Event Loop'un diger islemlere zaman vermesini saglamak icin kullanilir.

Node.js dokumantasyonu da setImmediate kullanmayi oneriyor cunku nextTick cok kullanilirsa Event Loop'u bloklar. Ben de genelde setImmediate tercih ediyorum, nextTick'i sadece gercekten gerektiginde kullaniyorum.

JavaScript:

// nextTick kullanim ornegi 1: Event emit oncesi zaman tanima
const EventEmitter = require('events');

class VeriTabani extends EventEmitter {
    constructor() {
        super();

        // Constructor'da hemen emit edersek, dinleyici henuz baglanmamis olabilir
        // YANLIS:
        // this.emit('baglandi'); // Dinleyici kacirir!

        // DOGRU: nextTick ile bekle
        process.nextTick(() => {
            this.emit('baglandi');
        });
    }
}

const db = new VeriTabani();

// Bu dinleyici, nextTick sayesinde emit'i yakalar
db.on('baglandi', () => {
    console.log('Veritabanina baglanildi!');
});

// nextTick kullanim ornegi 2: Her zaman asenkron davranis
function veriAl(id, callback) {
    if (!id) {
        // YANLIS: callback'i senkron cagirmak
        // callback(new Error('ID gerekli'));

        // DOGRU: Her zaman asenkron cagir
        process.nextTick(() => {
            callback(new Error('ID gerekli'));
        });
        return;
    }

    // Normal asenkron islem
    setTimeout(() => {
        callback(null, { id, veri: 'test' });
    }, 100);
}

// setImmediate kullanim ornegi: CPU-yogun islemi parcalama
function buyukDiziIsle(dizi, islemFn) {
    return new Promise((resolve) => {
        const sonuclar = [];
        let index = 0;
        const BATCH = 1000;

        function sonrakiBatch() {
            const bitis = Math.min(index + BATCH, dizi.length);

            for (let i = index; i < bitis; i++) {
                sonuclar.push(islemFn(dizi[i]));
            }

            index = bitis;

            if (index < dizi.length) {
                // setImmediate ile Event Loop'a nefes aldirdim
                setImmediate(sonrakiBatch);
            } else {
                resolve(sonuclar);
            }
        }

        sonrakiBatch();
    });
}

// Test
async function main() {
    const buyukDizi = Array.from({ length: 10000 }, (_, i) => i);

    console.log('\nBuyuk dizi isleniyor...');
    const baslangic = Date.now();

    const sonuclar = await buyukDiziIsle(buyukDizi, x => x * 2);

    console.log(`${sonuclar.length} eleman islendi (${Date.now() - baslangic}ms)`);
    console.log(`Ilk 5 sonuc: ${sonuclar.slice(0, 5)}`);
}

main();

Dikkat: nextTick Starvation

nextTick'in en buyuk tehlikesi starvation'a yol acmasidir. Eger nextTick icinde yeni nextTick eklemeye devam ederseniz, Event Loop hicbir zaman diger fazlara gecemez. Bu da setTimeout, setImmediate ve I/O callback'lerinin asla calismamasi demektir. setImmediate ile bu sorun yoktur cunku her immediate callback bir sonraki Event Loop iterasyonunda calisir.

Tecrubeme gore, eger ne kullanacaginizdan emin degilseniz setImmediate kullanin. nextTick'i sadece yukaridaki orneklerdeki gibi spesifik durumlarda kullanin. Ve asla recursive nextTick yapmayin, eger recursive bir is yapmaniz gerekiyorsa setImmediate kullanin. Bu kadar, bir sonraki konuda setTimeout ve setInterval'e bakacagiz!

Best Studio · Çarşamba saat 17:21'de

Emeğiniz ve katkınız için teşekkür ederiz!
Konunuz gerekli incelemelerden geçerek onaylandı. Topluluğumuza katkılarınızın devamını bekliyoruz.
İyi forumlar!

[NODE JS] process.nextTick ve setImmediate Farki

Silverhand