Ausführliche Erläuterung der Anwendungsbeispiele für Event-Listening und Event-Publishing in Node.js

node.js basiert auf nicht blockierender asynchroner E/A mit einem Thread, was bedeutet, dass der Thread bei einem E/A-Vorgang nicht blockiert, sondern die folgenden Vorgänge ausführt Woher weiß der Thread nach Abschluss des E/A-Vorgangs, dass der Vorgang abgeschlossen ist?

Wenn der Vorgang den zeitaufwändigen E/A-Vorgang abschließt, wird der Thread über den E/A-Vorgang in Form eines Ereignisses benachrichtigt. Der Thread verarbeitet dieses Ereignis zu einem bestimmten Zeitpunkt Fahren Sie mit dem nächsten Schritt fort. Um die asynchrone E/A abzuschließen, muss der Thread über einen Ereignisschleifenmechanismus verfügen, der ständig darauf besteht, ob unvollendete Ereignisse vorliegen, und die Verarbeitung dieser Ereignisse nacheinander abschließen.

Um E/A zu blockieren, stoppt ein Thread die Ausführung, wenn er auf einen zeitaufwändigen E/A-Vorgang stößt, und wartet auf den Abschluss des Vorgangs. Zu diesem Zeitpunkt kann der Thread keine anderen Vorgangsanforderungen annehmen. Um den Durchsatz bereitzustellen, müssen mehrere Threads erstellt werden, wobei jeder Thread auf eine Kundenanfrage reagieren muss. Gleichzeitig kann jedoch nur ein Thread auf einem CPU-Kern ausgeführt werden. Wenn mehrere Threads ausgeführt werden sollen, müssen sie zwischen verschiedenen Threads wechseln .

Daher reduziert node.js die Kosten für die Thread-Erstellung und den Thread-Wechsel in Multithreads. Es muss Speicher dafür zugewiesen und in den Zeitplan aufgenommen werden Gleichzeitig ist es beim Threadwechsel manchmal erforderlich, Speicher-Paging und andere Vorgänge durchzuführen. Diese Vorgänge können durch die Verwendung eines einzelnen Threads reduziert werden. Diese Programmiermethode weist jedoch auch Mängel auf und entspricht nicht dem Designdenken der Menschen.

node.js basiert auf dem Ereignismodus, um asynchrone E/A zu implementieren. Wenn es gestartet wird, prüft es kontinuierlich, ob noch nicht abgeschlossene Ereignisse vorhanden sind, und führt dann ein anderes Ereignis aus wird sein Benachrichtigen Sie den Thread in Form von Die Aufgaben sind in kleine Ereignisse unterteilt, und node.js eignet sich auch für die Verarbeitung einiger Szenarien mit hoher E/A und geringer Logik.

Das folgende Beispiel zeigt das asynchrone Lesen von Dateien:

var fs = require('fs'); 
fs.readFile('file.txt', 'utf-8', function(err, data) { 
if (err) { 
<span style="white-space:pre"> </span>console.error(err); 
} else { 
<span style="white-space:pre"> </span>console.log(data); 
} 
}); 
[javascript] view plain copy
console.log("end");

Wie obenfs.readFile Lesen Die Datei wird asynchron ausgeführt, und dann wird der Prozess fortgesetzt, ohne darauf zu warten, dass das Lesen der Datei abgeschlossen ist. Wenn die Datei gelesen wird, wird ein Ereignis freigegeben, und der Ausführungsthread führt den entsprechenden Vorgang aus, wenn er das Ereignis durchläuft Die entsprechende Callback-Funktion wird im Beispiel vor dem Dateiinhalt ausgegeben.

node.js-Ereignis-API

events.EventEmitter: EventEmitter bietet die Kapselung von Ereignisemissions- und Ereignisüberwachungsfunktionen in node.js für jedes Ereignis besteht aus einer Zeichenfolge, die den Ereignisnamen und die entsprechende Operation identifiziert.

Ereignisüberwachung:

var events = require("events"); 
var emitter = new events.EventEmitter(); 
 <span style="font-family: Arial, Helvetica, sans-serif;">emitter.on("eventName", function(){</span> 
  console.log("eventName事件发生") 
})

Veranstaltungsveröffentlichung:

emitter.emit("eventName");

Beim Veröffentlichen eines Ereignisses können wir mehrere Parameter übergeben. Der erste Parameter stellt den Namen des Ereignisses dar und die nachfolgenden Parameter stellen die übergebenen Parameter dar. Diese Parameter werden übergeben in die Event-Callback-Funktion.

EventEmitter.once("eventName", listener) : Registrieren Sie einen Listener für ein Ereignis, das nur einmal ausgeführt wird. Wenn das Ereignis zum ersten Mal auftritt und der Listener ausgelöst wird, wird der Listener freigegeben, wenn das Ereignis danach auftritt , wird der Listener freigegeben. Der Server wird nicht ausgeführt.

EventEmitter.removeListener(event, listener) : Entfernen Sie den Ereignis-Listener.

EventEmitter.removeAllListeners(event): Entfernen Sie alle Ereignis-Listener.

EventEmitter.setMaxListeners(n): Das Standardmaximum Die Anzahl der Listener für ein einzelnes Ereignis in node.js beträgt 10. Wenn sie 10 überschreitet, wird eine Warnung ausgegeben, um einen Speicherüberlauf zu verhindern. Wenn ein Wert von 0 festgelegt ist, bedeutet dies, dass es keine Einschränkung gibt .

EventEmitter.listeners(event) : Gibt die Listenerliste eines Ereignisses zurück

Zusammenarbeit zwischen mehreren Ereignissen
ist in einigen Fällen etwas größer Bei Anwendungen ist die Trennung zwischen Daten und Webservern unvermeidlich, z. B. Sina Weibo, Facebook, Twitter usw. Dies hat den Vorteil, dass die Datenquellen vereinheitlicht werden und verschiedene Rich-Client-Programme für dieselben Datenquellen entwickelt werden können.

Nehmen Sie Webanwendungen als Beispiel. Beim Rendern einer Seite ist es normalerweise erforderlich, Daten aus mehreren Datenquellen abzurufen und sie schließlich an den Client zu rendern. In diesem Szenario kann Node.js auf natürliche und bequeme Weise gleichzeitig Anfragen an mehrere Datenquellen gleichzeitig initiieren.

api.getUser("username", function (profile) {
 // Got the profile
});
api.getTimeline("username", function (timeline) {
 // Got the timeline
});
api.getSkin("username", function (skin) {
 // Got the skin
});

Node.js verwendet einen asynchronen Mechanismus, um Anfragen nicht blockierend zu machen, den Zweck paralleler Anfragen zu erreichen und zugrunde liegende Ressourcen effektiv aufzurufen. Das Problem in diesem Szenario besteht jedoch darin, dass die Koordination mehrerer Ereignisantwortergebnisse von Node.js nicht elegant nativ unterstützt wird.

Um Ergebnisse für alle drei Anfragen zu erhalten, bevor mit dem nächsten Schritt fortgefahren wird, kann das Programm in die folgende Situation geändert werden:

api.getUser("username", function (profile) {
 api.getTimeline("username", function (timeline) {
  api.getSkin("username", function (skin) {
   // TODO
  });
 });
});

Dies führt dazu, dass Anfragen seriell gestellt werden und die Nutzung des zugrunde liegenden API-Servers nicht maximiert werden kann.

为解决这类问题，我曾写作一个模块来实现多事件协作，以下为上面代码的改进版：

var proxy = new EventProxy();
proxy.all("profile", "timeline", "skin", function (profile, timeline, skin) {
 // TODO
});
api.getUser("username", function (profile) {
 proxy.emit("profile", profile);
});
api.getTimeline("username", function (timeline) {
 proxy.emit("timeline", timeline);
});
api.getSkin("username", function (skin) {
 proxy.emit("skin", skin);
});

EventProxy也是一个简单的事件侦听者模式的实现，由于底层实现跟Node.js的EventEmitter不同，无法合并进Node.js中。但是却提供了比EventEmitter更强大的功能，且API保持与EventEmitter一致，与Node.js的思路保持契合，并可以适用在前端中。
这里的all方法是指侦听完profile、timeline、skin三个方法后，执行回调函数，并将侦听接收到的数据传入。

利用事件队列解决雪崩问题

所谓雪崩问题，是在缓存失效的情景下，大并发高访问量同时涌入数据库中查询，数据库无法同时承受如此大的查询请求，进而往前影响到网站整体响应缓慢。

那么在Node.js中如何应付这种情景呢。

var select = function (callback) {
  db.select("SQL", function (results) {
   callback(results);
  });
 };

以上是一句数据库查询的调用，如果站点刚好启动，这时候缓存中是不存在数据的，而如果访问量巨大，同一句SQL会被发送到数据库中反复查询，影响到服务的整体性能。一个改进是添加一个状态锁。

var status = "ready";
var select = function (callback) {
  if (status === "ready") {
   status = "pending";
   db.select("SQL", function (results) {
    callback(results);
    status = "ready";
   });
  }
 };

但是这种情景，连续的多次调用select发，只有第一次调用是生效的，后续的select是没有数据服务的。所以这个时候引入事件队列吧：

var proxy = new EventProxy();
var status = "ready";
var select = function (callback) {
  proxy.once("selected", callback);
  if (status === "ready") {
   status = "pending";
   db.select("SQL", function (results) {
    proxy.emit("selected", results);
    status = "ready";
   });
  }
 };

这里利用了EventProxy对象的once方法，将所有请求的回调都压入事件队列中，并利用其执行一次就会将监视器移除的特点，保证每一个回调只会被执行一次。对于相同的SQL语句，保证在同一个查询开始到结束的时间中永远只有一次，在这查询期间到来的调用，只需在队列中等待数据就绪即可，节省了重复的数据库调用开销。由于Node.js单线程执行的原因，此处无需担心状态问题。这种方式其实也可以应用到其他远程调用的场景中，即使外部没有缓存策略，也能有效节省重复开销。此处也可以用EventEmitter替代EventProxy，不过可能存在侦听器过多，引发警告，需要调用setMaxListeners(0)移除掉警告，或者设更大的警告阀值。

Das obige ist der detaillierte Inhalt vonAusführliche Erläuterung der Anwendungsbeispiele für Event-Listening und Event-Publishing in Node.js. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!