Penjelasan terperinci tentang gelung acara Node.js (Gelung Acara) dan pool

"Gelung Peristiwa" Node ialah teras keupayaannya untuk mengendalikan konkurensi yang besar dan daya pemprosesan yang tinggi. Ini adalah bahagian yang paling ajaib, yang menurutnya Node.js pada dasarnya boleh difahami sebagai "benang tunggal", sambil juga membenarkan operasi sewenang-wenangnya diproses di latar belakang. Artikel ini akan menjelaskan cara gelung acara berfungsi supaya anda dapat merasakan keajaibannya.

Pengaturcaraan dipacu acara

Untuk memahami gelung acara, anda mesti memahami Pengaturcaraan Didorong Acara terlebih dahulu. Ia muncul pada tahun 1960. Pada masa kini, pengaturcaraan dipacu acara banyak digunakan dalam pengaturcaraan UI. Salah satu kegunaan utama JavaScript adalah untuk berinteraksi dengan DOM, jadi penggunaan API berasaskan peristiwa adalah semula jadi.

Ditakrifkan secara ringkas: Pengaturcaraan dipacu peristiwa mengawal aliran aplikasi melalui peristiwa atau perubahan dalam keadaan. Secara amnya dilaksanakan melalui pemantauan acara, setelah peristiwa itu dikesan (iaitu, keadaan berubah), fungsi panggil balik yang sepadan dipanggil. Bunyi biasa? Malah, ini ialah prinsip kerja asas gelung peristiwa Node.js.

Jika anda biasa dengan pembangunan JavaScript sisi klien, fikirkan kaedah .on*() tersebut, seperti element.onclick(), yang digunakan untuk bergabung dengan elemen DOM untuk menyampaikan interaksi pengguna. Mod kerja ini membolehkan berbilang peristiwa dicetuskan pada satu kejadian. Node.js mencetuskan mod ini melalui EventEmitters (penjana acara), seperti dalam modul Soket dan "http" di bahagian pelayan. Satu atau lebih perubahan keadaan boleh dicetuskan daripada satu kejadian.

Satu lagi corak biasa ialah menyatakan kejayaan dan kegagalan. Secara umumnya terdapat dua kaedah pelaksanaan biasa. Yang pertama ialah menghantar "Pengecualian ralat" ke dalam panggilan balik, biasanya sebagai parameter pertama kepada fungsi panggil balik. Yang kedua menggunakan corak reka bentuk Janji dan telah menambah ES6. Nota* Mod Promise menggunakan kaedah penulisan rantai fungsi yang serupa dengan jQuery untuk mengelakkan sarang dalam fungsi panggil balik, seperti:

Salin kod Kod adalah seperti berikut:

$.getJSON('/getUser').done(successHandler).fail(failHandler)

Modul "fs" (sistem fail) kebanyakannya menggunakan gaya menghantar pengecualian ke dalam panggilan balik. Secara teknikal mencetuskan panggilan tertentu, seperti peristiwa dilampirkan fs.readFile(), tetapi API hanyalah untuk memaklumkan pengguna dan menyatakan kejayaan atau kegagalan operasi. Pilihan API sedemikian adalah berdasarkan pertimbangan seni bina dan bukannya batasan teknikal.

Salah tanggapan yang lazim ialah pemancar peristiwa juga tidak segerak semasa menembak peristiwa, tetapi ini tidak betul. Di bawah ialah coretan kod ringkas untuk menunjukkan perkara ini.

Salin kod Kod adalah seperti berikut:

fungsi MyEmitter() {
EventEmitter.call(this);
}
util.inherits(MyEmitter, EventEmitter);

MyEmitter.prototype.doStuff = fungsi doStuff() {
console.log('sebelum')
emitter.emit('fire')
console.log('selepas')}
};

var saya = MyEmitter();
me.on('fire', function() {
console.log('emit fired');
});

me.doStuff();
// Output:
// sebelum
// memancarkan tembakan
// selepas

Nota* Jika emitter.emit tidak segerak, output hendaklah
// sebelum
// selepas
// memancarkan tembakan

EventEmitter selalunya berkelakuan tidak segerak kerana ia sering digunakan untuk memberitahu operasi yang perlu diselesaikan secara tidak segerak, tetapi API EventEmitter itu sendiri adalah segerak sepenuhnya. Fungsi mendengar boleh dilaksanakan secara tidak segerak secara dalaman, tetapi sila ambil perhatian bahawa semua fungsi mendengar akan dilaksanakan secara serentak mengikut susunan ia ditambah.

Gambaran keseluruhan mekanisme dan kumpulan benang

Nod sendiri bergantung pada berbilang perpustakaan. Salah satunya ialah libuv, perpustakaan yang menakjubkan untuk mengendalikan baris gilir dan pelaksanaan acara tak segerak.

Node menggunakan sebanyak mungkin kernel sistem pengendalian untuk melaksanakan fungsi sedia ada. Seperti menjana permintaan respons, memajukan sambungan dan mempercayakannya kepada sistem untuk diproses. Sebagai contoh, sambungan masuk dibariskan melalui sistem pengendalian sehingga ia boleh dikendalikan oleh Node.

Anda mungkin pernah mendengar bahawa Node mempunyai kumpulan benang, dan anda mungkin tertanya-tanya: "Jika Node akan memproses tugasan mengikut urutan, mengapa kita memerlukan kumpulan benang Ini kerana dalam kernel, tidak semua tugasan diproses masuk?" pesanan. Dilaksanakan secara tidak segerak. Dalam kes ini, Node.JS mesti boleh mengunci benang untuk tempoh masa tertentu semasa beroperasi supaya ia boleh terus melaksanakan gelung acara tanpa disekat.

Berikut ialah contoh rajah mudah untuk menunjukkan mekanisme pengendalian dalamannya:

┌─────────────────────┐
╭──►│ pemasa pemasa │       └───────────┬───────────┘
│       ┌───────────┴───────────┐
│ panggilan balik belum selesai │ │          └──────────┬───────────┘                                                                                                                                                                                                                                                                      | │ │ │ UNDIAN ││── Sambungan, │
│                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               . │                                                                                                                                                                                                                                                                                                            . ╰─── ┤ setSegera └───────────────────────┘

Terdapat beberapa perkara yang sukar difahami tentang kerja dalaman gelung peristiwa:

Semua panggilan balik akan dipratetap melalui process.nextTick() pada penghujung satu peringkat gelung acara (cth., pemasa) dan sebelum beralih ke peringkat seterusnya. Ini akan mengelakkan kemungkinan panggilan rekursif ke process.nextTick(), menyebabkan gelung tak terhingga.
"Panggil balik belum selesai" ialah panggilan balik dalam baris gilir panggil balik yang tidak akan diproses oleh mana-mana kitaran gelung peristiwa lain (contohnya, dihantar ke fs.write).

Pemancar Peristiwa dan Gelung Peristiwa

Permudahkan interaksi dengan gelung acara dengan mencipta Pemancar Acara. Ia adalah pembalut generik yang membolehkan anda membuat API berasaskan acara dengan lebih mudah. Cara kedua-duanya berinteraksi sering menyebabkan pembangun keliru.

Contoh berikut menunjukkan bahawa melupakan peristiwa dicetuskan secara serentak boleh menyebabkan acara terlepas.

Salin kod Kod adalah seperti berikut:

// Selepas v0.10, require('events').EventEmitter tidak lagi diperlukan
var EventEmitter = memerlukan('events');
var util = memerlukan('util');

fungsi MyThing() {
EventEmitter.call(this);

doFirstThing();
this.emit('thing1');
}
util.inherits(MyThing, EventEmitter);

var mt = MyThing();

mt.on('thing1', function onThing1() {
// Maaf, acara ini tidak akan berlaku
});

Peristiwa 'thing1' di atas tidak akan pernah ditangkap oleh MyThing() kerana MyThing() mesti dijadikan instantiated sebelum ia boleh mendengar acara. Berikut ialah penyelesaian mudah tanpa menambah sebarang penutupan tambahan:

Salin kod Kod adalah seperti berikut:

var EventEmitter = memerlukan('events');
var util = memerlukan('util');

fungsi MyThing() {
EventEmitter.call(this);

doFirstThing();
setImmediate(emitThing1, this);
}
util.inherits(MyThing, EventEmitter);

fungsi emitThing1(self) {
self.emit('thing1');
}

var mt = MyThing();

mt.on('thing1', function onThing1() {
// Dilaksanakan
});

Penyelesaian berikut juga akan berfungsi, tetapi dengan mengorbankan beberapa prestasi:

Salin kod Kod adalah seperti berikut:

fungsi MyThing() {
EventEmitter.call(this);

doFirstThing();
// Menggunakan Function#bind() akan kehilangan prestasi
setImmediate(this.emit.bind(this, 'thing1'));
}
util.inherits(MyThing, EventEmitter);

Masalah lain ialah mencetuskan Ralat. Mencari masalah dalam aplikasi anda cukup sukar, tetapi tanpa timbunan panggilan (nota *e.stack), penyahpepijatan hampir mustahil. Apabila Ralat diterima oleh permintaan tak segerak jauh, timbunan panggilan akan hilang. Terdapat dua penyelesaian yang mungkin: pencetus secara serentak atau pastikan Ralat dihantar bersama dengan maklumat penting yang lain. Contoh di bawah menunjukkan kedua-dua penyelesaian:

Salin kod Kod adalah seperti berikut:

MyThing.prototype.foo = function foo() {
// Ralat ini akan dicetuskan secara tak segerak
var er = doFirstThing();
jika (er) {
//Apabila dicetuskan, ralat baharu perlu dibuat untuk mengekalkan maklumat tindanan panggilan di tapak
setImmediate(emitError, this, new Error('Bad Bad'));
Kembali;
}

// Ralat pencetus dan kendalikannya dengan segera (segerak)
var er = doSecondThing();
jika (er) {
This.emit('error', 'Lebih banyak perkara buruk');
Kembali;
}
}

Menilai keadaan. Apabila ralat dicetuskan, ia boleh dikendalikan dengan segera. Atau, ia mungkin beberapa pengecualian remeh yang boleh dikendalikan dengan mudah, atau ditangani kemudian. Di samping itu, menghantar Ralat melalui pembina bukanlah idea yang baik, kerana contoh objek yang dibina mungkin tidak lengkap. Kes di mana Ralat dilemparkan secara langsung tadi adalah pengecualian.

Kesimpulan

Artikel ini membincangkan secara ringkas kerja dalaman dan butiran teknikal bagi gelung acara. Semuanya difikirkan dengan baik. Artikel lain akan membincangkan interaksi gelung acara dengan kernel sistem dan menunjukkan keajaiban operasi tak segerak NodeJS.