Artikel untuk bercakap tentang mekanisme gelung peristiwa dalam Node.js

Artikel ini akan membawa anda melalui mekanisme gelung peristiwa (gelung masa) dalam Node.js saya harap ia akan membantu anda.

Hari ini kita akan belajar tentang gelung peristiwa dalam nodeJs. Pemahaman tentang event-loop sentiasa menjadi kesukaran yang besar bagi saya. Saya berharap dapat menempuhi kesulitan ini melalui kajian ini.

libuv

Sebelum mempelajari gelung peristiwa, fahami dahulu libuv nod. libuv bertanggungjawab untuk pelaksanaan model I/O yang berbeza pada sistem pengendalian yang berbeza dan mengabstrakkan pelaksanaan yang berbeza ke dalam API yang boleh digunakan pada aplikasi pihak ketiga.

Soalan

Sebelum secara formal mempelajari acara-gelung, fikirkan soalan dahulu

    setTimeout(() => {
      console.log("timer1");
      Promise.resolve().then(() => {
        console.log("promise1");
      });
    }, 0);

    setTimeout(() => {
      console.log("timer2");
      Promise.resolve().then(() => {
        console.log("promise2");
      });
    }, 0);

Ini Apakah hasil menjalankan kod ini dalam penyemak imbas?

Apakah hasil menjalankannya dalam nod?

Sebelum nod8.6:

Selepas nod8.6:

Mengapa ada keputusan sedemikian, kami akan menganalisisnya kemudian!

gelung peristiwa dalam nodeJs

Pertama sekali , Mari lihat gambar:

Anda boleh melihat 6 peringkat dalam gambar, iaitu: pemasa, panggilan balik belum selesai, melahu/sediakan, tinjauan pendapat, semak, tutup panggilan balik.

• fasa pemasa: terutamanya melaksanakan setTimeOut, setInterval panggil balik

• fasa panggil balik belum selesai: laksanakan beberapa ralat panggilan sistem, seperti Ralat komunikasi rangkaian panggil balik

• fasa melahu/menyediakan: hanya digunakan dalam sistem (kami tidak boleh mengawal dan mengganggu fasa ini)

• fasa undian: dapatkan I/ O peristiwa, seperti mendapatkan panggilan balik I/O untuk membaca fail. Dalam keadaan yang sesuai, nodej akan menyekat dalam fasa ini

• fasa semak: laksanakan setPanggil balik segera

• Contohnya Laksanakan musnahkan dan tutup panggilan balik acara sokect

Setiap peringkat mengikut peraturan FIFO (Mula-mula masuk dahulu) untuk melaksanakan tugas baris gilir tugas di dalam . Antara enam peringkat ini, kita perlu menumpukan pada peringkat pemasa, tinjauan pendapat, semak. Kebanyakan tugas tak segerak dalam pembangunan harian kita dikendalikan dalam tiga peringkat ini.

pemasa

Mari kita bincangkan tentang peringkat pemasa dahulu.
Pemasa ialah peringkat pertama gelung acara Nodejs akan menyemak sama ada terdapat pemasa tamat tempoh, dan jika ya, masukkan panggilan baliknya ke dalam baris gilir. Walau bagaimanapun, nodejs tidak boleh menjamin bahawa pemasa akan melaksanakan panggilan balik dengan serta-merta apabila acara pratetap tiba Ini kerana semakan tamat tempoh pemasa oleh nodejs tidak semestinya boleh dipercayai menghadapi situasi utama semasa.
Mengenai ketidakpastian di sini, tapak web rasmi memberikan contoh:
Mula-mula mengisytiharkan setTimeOut, dan kemudian membaca fail secara luaran Apabila operasi membaca fail melebihi masa pemasa, operasi Fail baca akan melambatkan panggilan balik pemasa Ini adalah keadaan di mana utas utama tidak terbiar seperti yang dinyatakan sebelum ini.

tinjauan pendapat

Fasa tinjauan pendapat terutamanya melaksanakan dua perkara:

1 Memproses baris gilir tugasan fasa tinjauan pendapat

2 . Apabila terdapat pemasa yang telah tamat masa, fungsi panggil baliknya dilaksanakan

Dalam rajah di atas, kita juga boleh melihat: Selepas melaksanakan baris gilir tugas tinjauan pendapat dalam fasa tinjauan Selepas tugas, ia akan menyemak sama ada terdapat set pratetapSegera Jika ada, ia akan memasuki fasa semak Jika tidak, nodejs akan menyekat di sini.

Di sini kita akan mempunyai soalan Jika ia disekat dalam peringkat tinjauan pendapat, bukankah pemasa yang kita tetapkan tidak boleh dilaksanakan?
MalahApabila gelung acara disekat dalam fasa tinjauan pendapat, nodej akan mempunyai mekanisme semakan Ia akan menyemak sama ada baris gilir pemasa kosong, ia akan memasuki semula pemasa fasa.

semak

Fungsi panggil balik utama setImmediate dilaksanakan semasa fasa semakan.

小总结

event-loop的每个阶段都有一个队列，当event-loop达到某个阶段之后，将执行这个阶段的任务队列，直到队列清空或者达到系统规定的最大回调限制之后，才会进入下一个阶段。当所有阶段都执行完成一次之后，称event-loop完成一个tick。

案例

上面我们说完了event-loop的理论部分，但是光有理论我们也还是不能很清晰的理解event-loop。下面我们就根据几个demo来更加深入的理解下event-loop！

demo1

    const fs=require('fs')
    fs.readFile('test.txt',()=>{
            console.log('readFile')
            setTimeout(()=>{
                    console.log('settimeout');
            },0)
            setImmediate(()=>{
                    console.log('setImmediate')
            })
    })

执行结果：

可见执行结果跟我们前面的分析时一致的！

demo2

    const fs = require("fs");
    const EventEmitter = require("events").EventEmitter;
    let pos = 0;
    const messenger = new EventEmitter();

    messenger.on("message", function (msg) {
      console.log(++pos + " message:" + msg); //
    });

    console.log(++pos + " first"); //

    process.nextTick(function () {
      console.log(++pos + " nextTick"); //
    });

    messenger.emit("message", "hello!");
    fs.stat(__filename, function () {
      console.log(++pos + " stat"); //
    });

    setTimeout(function () {
      console.log(++pos + " quick timer"); //
    }, 0);
    setTimeout(function () {
      console.log(++pos + " long timer"); //
    }, 30);
    setImmediate(function () {
      console.log(++pos + " immediate"); //
    });

    console.log(++pos + " last"); //

结果：

了解下浏览器和node的event-loop差异在什么地方

在node 8.6 之前：

浏览器中的微任务队列会在每个宏任务执行完成之后执行，而node中的微任务会在事件循环的各个阶段之间执行，即每个阶段执行完成之后会去执行微任务队列。

在8.6之后：

浏览器和node中微任务的执行是一致的！

所以，在文章开头，我们提出的思考的问题就有了结果。

关于 process.nextTick()和setImmediate

process.nextTick()

语法：process.nextTick(callback,agrs)

执行时机：

这个函数其实是独立于 Event Loop 之外的，它有一个自己的队列，当每个阶段完成后，如果存在 nextTick 队列，就会清空队列中的所有回调函数，并且优先于其他 microtask 执行。递归的调用process.nextTick()会导致I/O starving，官方推荐使用setImmediate()

关于starving现象的说明：

    const fs = require("fs");
    fs.readFile("test.txt", (err, msg) => {
      console.log("readFile");
    });

    let index = 0;

    function handler() {
      if (index >= 30) return;
      index++;
      console.log("nextTick" + index);
      process.nextTick(handler);
    }

    handler();

运行结果:

可以看到，等到nextTick函数呗执行30次之后，读取文件的回调才被执行！这样的现象被称为 I/O 饥饿。

当我们把 process.nextTick 换为 setImmediate

    const fs = require("fs");
    fs.readFile("test.txt", (err, msg) => {
      console.log("readFile");
    });

    let index = 0;

    function handler() {
      if (index >= 30) return;
      index++;
      console.log("nextTick" + index);
      setImmediate(handler);
    }

    handler();

结果：

造成这两种差异的原因是，嵌套调用的setImmediate的回调被排到了下一次event-loop中去！

event-loop核心思维导图

结束语

通过今天的学习，让我对event-loop的理解更深刻了。那么，下次见。好好学习，天天向上！

更多编程相关知识，请访问：编程视频！！

Atas ialah kandungan terperinci Artikel untuk bercakap tentang mekanisme gelung peristiwa dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!