Welche Methoden gibt es, damit Cluster den Speicher gemeinsam nutzen?

Dieses Mal zeige ich Ihnen, wie Sie Cluster dazu bringen, den Speicher zu teilen, und welche Vorsichtsmaßnahmen es gibt, um Cluster dazu zu bringen, den Speicher zu teilen. Das Folgende ist ein praktischer Fall, schauen wir uns das an.

Die Standard-API von Node.js bietet keinen Prozess-Shared-Memory. Durch die Sendemethode der IPC-Schnittstelle und die Überwachung von Nachrichtenereignissen kann jedoch ein Mechanismus für die Zusammenarbeit zwischen mehreren Prozessen implementiert werden, um Shared-Memory zu betreiben Kommunikation.

##Grundlegende Verwendung von IPC:

// worker进程 发送消息
process.send(‘读取共享内存');
 
// master进程 接收消息 -> 处理 -> 发送回信
cluster.on('online', function (worker) {
   // 有worker进程建立，即开始监听message事件
   worker.on(‘message', function(data) {
     // 处理来自worker的请求
     // 回传结果
     worker.send(‘result')
   });
});

In Node.js über send und on('message', Die durch Callback implementierte IPC-Kommunikation weist mehrere Merkmale auf. Erstens können Master und Worker miteinander kommunizieren, Worker können jedoch nicht direkt miteinander kommunizieren, Worker können jedoch indirekt über die Master-Weiterleitung kommunizieren. Darüber hinaus werden die über die Sendemethode übergebenen Daten vor der Weitergabe von JSON.stringify verarbeitet. Nach dem Empfang werden sie mit JSON.parse analysiert. Daher wird das Buffer-Objekt nach der Übergabe zu einem Array, die Funktion kann jedoch nicht direkt übergeben werden. Andererseits können alle Datentypen außer Puffer und Funktion direkt übertragen werden (was bereits sehr leistungsfähig ist, und Puffer und Funktion können auch mit alternativen Methoden übertragen werden).

Basierend auf den oben genannten Merkmalen können wir eine Lösung für die Speicherfreigabe über IPC entwerfen:

1. Als Benutzer des gemeinsam genutzten Speichers betreibt der Arbeitsprozess den gemeinsam genutzten Speicher nicht direkt, sondern benachrichtigt den Masterprozess über die Sendemethode, um Schreib- (Setz) oder Lesevorgänge (Get) auszuführen.

2. Der Masterprozess initialisiert ein Objektobjekt als gemeinsam genutzten Speicher und liest und schreibt den Schlüsselwert des Objekts gemäß der vom Worker gesendeten Nachricht.

3. Da prozessübergreifende Kommunikation verwendet wird, handelt es sich bei den vom Worker initiierten Set- und Get-Vorgängen um asynchrone Vorgänge. Der Master führt tatsächliche Lese- und Schreibvorgänge gemäß der Anforderung aus und gibt die Ergebnisse dann an den Worker zurück (d. h. das Ergebnis senden). Daten an den Arbeitnehmer).

##Datenformat

Um asynchrone Lese- und Schreibfunktionen zwischen Prozessen zu implementieren, muss das Format der Kommunikationsdaten standardisiert werden.

Das erste sind die Anforderungsdaten des Arbeitnehmers:

requestMessage = {
  isSharedMemoryMessage: true, // 表示这是一次共享内存的操作通信
  method: ‘set', // or ‘get' 操作的方法
  id: cluster.worker.id, // 发起操作的进程（在一些特殊场景下，用于保证master可以回信）
  uuid: uuid, // 此次操作的（用于注册/调用回调函数）
  key: key, // 要操作的键
  value: value // 键对应的值（写入）
}

Nach dem Empfang der Daten führt der Master die entsprechenden Vorgänge gemäß der Methode aus und sendet dann die Ergebnisdaten gemäß requestMessage.id an den entsprechenden Worker. Das Datenformat lautet wie folgt:

responseMessage = {
  isSharedMemoryMessage: true, // 标记这是一次共享内存通信
  uuid: requestMessage.uuid, // 此次操作的唯一标示
  value: value // 返回值。get操作为key对应的值，set操作为成功或失败
}

Die Bedeutung der Standardisierung des Datenformats besteht darin, dass der Master nach Erhalt der Anforderung das Verarbeitungsergebnis an den entsprechenden Mitarbeiter senden kann und der Mitarbeiter nach Erhalt des zurückgegebenen Ergebnisses den der Kommunikation entsprechenden Rückruf aufrufen und so eine Zusammenarbeit erreichen kann.

Nach der Standardisierung des Datenformats müssen als Nächstes zwei Codesätze für den Master-Prozess und den Worker-Prozess entworfen werden, um die Kommunikation zu überwachen und Kommunikationsdaten zu verarbeiten, um die Funktion des gemeinsam genutzten Speichers zu realisieren.

##Benutzerklasse

Instanzen der User-Klasse arbeiten im Worker-Prozess und sind dafür verantwortlich, Anforderungen zum Betrieb des gemeinsam genutzten Speichers zu senden und auf Antworten vom Master zu warten.

var User = function() {
  var self = this;
  self.uuid = 0;
 
  // 缓存回调函数
  self.getCallbacks = {};
 
  // 接收每次操作请求的回信
  process.on('message', function(data) {
    
    if (!data.isSharedMemoryMessage) return;
    // 通过uuid找到相应的回调函数
    var cb = self.getCallbacks[data.uuid];
    if (cb && typeof cb == 'function') {
      cb(data.value)
    }
    // 卸载回调函数
    self.getCallbacks[data.uuid] = undefined;
  });
};
 
// 处理操作
User.prototype.handle = function(method, key, value, callback) {
 
  var self = this;
  var uuid = self.uuid++;
 
  process.send({
    isSharedMemoryMessage: true,
    method: method,
    id: cluster.worker.id,
    uuid: uuid,
    key: key,
    value: value
  });
 
  // 注册回调函数
  self.getCallbacks[uuid] = callback;
 
};
 
User.prototype.set = function(key, value, callback) {
  this.handle('set', key, value, callback);
};
 
User.prototype.get = function(key, callback) {
  this.handle('get', key, null, callback);
};

##Manager-Klasse

Instanzen der Manager-Klasse arbeiten im Masterprozess, um ein Objekt als gemeinsam genutzten Speicher zu initialisieren und entsprechend der Anforderung der Benutzerinstanz Schlüssel-Wert-Paare zum gemeinsam genutzten Speicher hinzuzufügen oder den Schlüsselwert zu lesen und dann das Ergebnis zu senden zurück.

var Manager = function() {
 
  var self = this;
  
  // 初始化共享内存
  self.sharedMemory = {};
    
  // 监听并处理来自worker的请求
  cluster.on('online', function(worker) {
    worker.on('message', function(data) {
      // isSharedMemoryMessage是操作共享内存的通信标记
      if (!data.isSharedMemoryMessage) return;
      self.handle(data);
    });
  });
};
 
Manager.prototype.handle = function(data) {
  var self = this;
  var value = this[data.method](data);
 
  var msg = {
    // 标记这是一次共享内存通信
    isSharedMemoryMessage: true,       
    // 此次操作的唯一标示
    uuid: data.uuid,
    // 返回值
    value: value
  };
 
  cluster.workers[data.id].send(msg);
};
 
// set操作返回ok表示成功
Manager.prototype.set = function(data) {
  this.sharedMemory[data.key] = data.value;
  return 'OK';
};
 
// get操作返回key对应的值
Manager.prototype.get = function(data) {
  return this.sharedMemory[data.key];
};

##Anwendung

if (cluster.isMaster) {
 
  // 初始化Manager的实例
  var sharedMemoryManager = new Manager();
 
  // fork第一个worker
  cluster.fork();
 
  // 1秒后fork第二个worker
  setTimeout(function() {
    cluster.fork();
  }, 1000);
   
} else {
 
  // 初始化User类的实例
  var sharedMemoryUser = new User();
 
  if (cluster.worker.id == 1) {
    // 第一个worker向共享内存写入一组数据，用a标记
    sharedMemoryUser.set('a', [0, 1, 2, 3]);
  }
 
  if (cluster.worker.id == 2) {
    // 第二个worker从共享内存读取a的值
    sharedMemoryUser.get('a', function(data) {
      console.log(data); // => [0, 1, 2, 3]
    });
  }
  
}

Das Obige ist eine Multiprozess-Shared-Memory-Funktion, die durch IPC-Kommunikation implementiert wird. Es ist zu beachten, dass diese Methode Daten direkt im Speicher des Master-Prozesses zwischenspeichert. Sie müssen auf die Speichernutzung achten Hier einige einfache Eliminierungsstrategien zur Optimierung der Speichernutzung. Wenn außerdem die auf einmal gelesenen und geschriebenen Daten relativ groß sind, erhöht sich auch der Zeitaufwand für die IPC-Kommunikation entsprechend. Ich glaube, dass Sie die Methode beherrschen, nachdem Sie den Fall in diesem Artikel gelesen haben. Weitere spannende Informationen finden Sie in anderen verwandten Artikeln auf der chinesischen PHP-Website!

Empfohlene Lektüre:

Das obige ist der detaillierte Inhalt vonWelche Methoden gibt es, damit Cluster den Speicher gemeinsam nutzen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!