Adakah javascript bahasa berbilang benang?

Untuk lebih memahami Gelung Acara, sila lihat gambar di bawah.

Dalam gambar di atas, apabila utas utama berjalan, timbunan dan timbunan dijana Kod dalam timbunan memanggil pelbagai API luaran. tugas" Tambah pelbagai acara (klik, muatkan, selesai) pada baris gilir". Selagi kod dalam timbunan dilaksanakan, utas utama akan membaca "baris gilir tugas" dan melaksanakan fungsi panggil balik yang sepadan dengan peristiwa tersebut dalam urutan.

Kod dalam timbunan pelaksanaan (tugas segerak) sentiasa dilaksanakan sebelum membaca "gilir tugas" (tugas tak segerak). Lihat contoh di bawah.

    var req = new XMLHttpRequest();
    req.open('GET', url);    
    req.onload = function (){};    
    req.onerror = function (){};    
    req.send();

Kaedah req.send dalam kod di atas ialah operasi Ajax untuk menghantar data ke pelayan Ia adalah tugas tak segerak, yang bermaksud bahawa sistem tidak akan membaca tugas sehingga semua kod skrip semasa dilaksanakan. Oleh itu, ia bersamaan dengan tulisan berikut.

 var req = new XMLHttpRequest();
    req.open('GET', url);
    req.send();
    req.onload = function (){};    
    req.onerror = function (){};

Maksudnya, bahagian yang menentukan fungsi panggil balik (onload dan onerror) tidak kira sebelum atau selepas kaedah send(), kerana ia tergolong dalam sebahagian daripada timbunan pelaksanaan, dan sistem sentiasa melaksanakannya, akan membaca "baris gilir tugas".

Pemasa

Selain meletakkan acara untuk tugas tak segerak, "baris gilir tugas" juga boleh meletakkan acara bermasa, iaitu, menentukan tempoh kod tertentu akan dilaksanakan selepas. Ini dipanggil fungsi "pemasa", iaitu kod yang dilaksanakan dengan kerap.

Fungsi pemasa terutamanya dilengkapkan oleh dua fungsi setTimeout() dan setInterval() Mekanisme operasi dalaman mereka adalah sama persis kod yang ditentukan oleh bekas

adalah dilaksanakan sekali , yang terakhir dilaksanakan berulang kali. Yang berikut terutamanya membincangkan setTimeout().

setTimeout() menerima dua parameter, yang pertama ialah fungsi panggil balik dan yang kedua ialah bilangan milisaat untuk menangguhkan pelaksanaan.

console.log(1);
setTimeout(function(){console.log(2);},1000);
console.log(3);

Hasil pelaksanaan kod di atas ialah 1, 3, 2, kerana setTimeout() menangguhkan pelaksanaan baris kedua sehingga 1000 milisaat kemudian.

Jika parameter kedua setTimeout() ditetapkan kepada 0, ini bermakna selepas kod semasa dilaksanakan (timbunan pelaksanaan dikosongkan), fungsi panggil balik yang ditentukan akan dilaksanakan serta-merta (selang 0 milisaat)

 setTimeout(function(){console.log(1);}, 0);
console.log(2);

Hasil pelaksanaan kod di atas sentiasa 2, 1, kerana hanya selepas baris kedua dilaksanakan, sistem akan melaksanakan fungsi panggil balik dalam "baris gilir tugas".

Ringkasnya, maksud setTimeout(fn,0) ialah untuk menentukan tugasan yang akan dilaksanakan dalam masa terbiar terawal yang tersedia bagi utas utama, iaitu, untuk dilaksanakan seawal mungkin. Ia menambahkan acara pada penghujung "baris gilir tugas", jadi ia tidak akan dilaksanakan sehingga tugas penyegerakan dan acara sedia ada dalam "baris gilir tugas" telah diproses.

Piawaian HTML5 menetapkan bahawa nilai minimum (selang terpendek) parameter kedua setTimeout() mestilah tidak kurang daripada 4 milisaat Jika lebih rendah daripada nilai ini, ia akan meningkat secara automatik. Sebelum ini, pelayar lama menetapkan selang minimum kepada 10 milisaat. Selain itu, perubahan DOM tersebut (terutamanya yang melibatkan pemaparan semula halaman) biasanya tidak dilaksanakan serta-merta, tetapi setiap 16 milisaat. Pada masa ini, kesan penggunaan requestAnimationFrame() adalah lebih baik daripada setTimeout().

Perlu diambil perhatian bahawa setTimeout() hanya memasukkan acara ke dalam "baris gilir tugasan Utas utama mesti menunggu sehingga kod semasa (timbunan pelaksanaan) selesai dilaksanakan sebelum utas utama melaksanakan fungsi panggil balik itu". menentukan. Jika kod semasa mengambil masa yang lama, ia mungkin mengambil masa yang lama, jadi tiada cara untuk menjamin bahawa fungsi panggil balik akan dilaksanakan pada masa yang ditentukan oleh setTimeout().

Gelung Peristiwa Node.js

Node.js juga merupakan Gelung Peristiwa satu benang, tetapi mekanisme pengendaliannya berbeza daripada persekitaran penyemak imbas.

Sila lihat rajah di bawah

Mengikut rajah di atas, mekanisme pengendalian Node.js adalah seperti berikut.

(1) Enjin V8 menghuraikan skrip JavaScript.

(2) Kod yang dihuraikan memanggil API Nod.

(3) Pustaka libuv bertanggungjawab untuk pelaksanaan API Node. Ia memperuntukkan tugas yang berbeza kepada utas yang berbeza untuk membentuk Gelung Acara (gelung peristiwa), dan mengembalikan hasil pelaksanaan tugas kepada enjin V8 secara tak segerak.

(4) Enjin V8 mengembalikan hasilnya kepada pengguna.

Selain daripada dua kaedah setTimeout dan setInterval, Node.js juga menyediakan dua kaedah lain yang berkaitan dengan "task queue": process.nextTick dan setImmediate. Mereka boleh membantu kita memperdalam pemahaman kita tentang "barisan tugas".

Kaedah process.nextTick boleh mencetuskan fungsi panggil balik pada penghujung "tindanan pelaksanaan" semasa—sebelum Gelung Peristiwa seterusnya (urutan utama membaca "barisan tugas"). Iaitu, tugas yang ditentukannya sentiasa berlaku sebelum semua tugas tak segerak. Kaedah setImmediate menambah acara ke penghujung "baris gilir tugas" semasa, iaitu, tugas yang ditentukannya sentiasa dilaksanakan dalam Gelung Acara seterusnya, yang hampir sama dengan setTimeout(fn, 0). Lihat contoh di bawah (melalui StackOverflow).

 process.nextTick(function A() {
  console.log(1);
  process.nextTick(function B(){console.log(2);});
});
 
setTimeout(function timeout() {
  console.log('TIMEOUT FIRED');
}, 0)
// 1
// 2
// TIMEOUT FIRED

上面代码中，由于process.nextTick方法指定的回调函数，总是在当前”执行栈”的尾部触发，所以不仅函数A比setTimeout指定的回调函数timeout先执行，而且函数B也比timeout先执行。这说明，如果有多个process.nextTick语句（不管它们是否嵌套），将全部在当前”执行栈”执行。

现在，再看setImmediate。

 setImmediate(function A() {
  console.log(1);
  setImmediate(function B(){console.log(2);});
});
 
setTimeout(function timeout() {
  console.log('TIMEOUT FIRED');
}, 0);

上面代码中，setImmediate与setTimeout(fn,0)各自添加了一个回调函数A和timeout，都是在下一次Event Loop触发。那么，哪个回调函数先执行呢？答案是不确定。运行结果可能是1–TIMEOUT FIRED–2，也可能是TIMEOUT FIRED–1–2。

令人困惑的是，Node.js文档中称，setImmediate指定的回调函数，总是排在setTimeout前面。实际上，这种情况只发生在递归调用的时候。

 setImmediate(function (){
  setImmediate(function A() {
    console.log(1);
    setImmediate(function B(){console.log(2);});
  });
 
  setTimeout(function timeout() {
    console.log('TIMEOUT FIRED');
  }, 0);
});
// 1
// TIMEOUT FIRED
// 2

上面代码中，setImmediate和setTimeout被封装在一个setImmediate里面，它的运行结果总是1–TIMEOUT FIRED–2，这时函数A一定在timeout前面触发。至于2排在TIMEOUT FIRED的后面（即函数B在timeout后面触发），是因为setImmediate总是将事件注册到下一轮Event Loop，所以函数A和timeout是在同一轮Loop执行，而函数B在下一轮Loop执行。

我们由此得到了process.nextTick和setImmediate的一个重要区别：多个process.nextTick语句总是在当前”执行栈”一次执行完，多个setImmediate可能则需要多次loop才能执行完。事实上，这正是Node.js 10.0版添加setImmediate方法的原因，否则像下面这样的递归调用process.nextTick，将会没完没了，主线程根本不会去读取”事件队列”！

 process.nextTick(function foo() {
  process.nextTick(foo);
});

事实上，现在要是你写出递归的process.nextTick，Node.js会抛出一个警告，要求你改成setImmediate。

另外，由于process.nextTick指定的回调函数是在本次”事件循环”触发，而setImmediate指定的是在下次”事件循环”触发，所以很显然，前者总是比后者发生得早，而且执行效率也高（因为不用检查”任务队列”）。

【相关推荐：javascript学习教程】