Penjelasan terperinci tentang beberapa kaedah pelaksanaan komunikasi proses dalam nod

nodBagaimana untuk berkomunikasi antara proses? Artikel berikut akan membantu anda memahami kaedah komunikasi proses nod dan cara melaksanakan kaedah komunikasi ini dalam nod saya harap ia akan membantu anda!

Komunikasi sebenarnya merangkumi semua peringkat pembangunan yang biasa termasuk klien dan pelayan berkomunikasi melalui pelbagai protokol komunikasi, komunikasi RPC, dan komunikasi antara pelbagai modul semasa proses pembangunan , komunikasi antara proses utama elektron dan proses pemaparan, dsb.;

Artikel ini terutamanya cuba meringkaskan kaedah komunikasi nodej (benang tunggal, berbilang benang, berbilang proses) , menggunakan Senario, pelaksanaan, dsb.

Cara komunikasi dilaksanakan

Komunikasi proses umum dilaksanakan seperti berikut:

1 >2. Soket (soket);

3. Baris gilir mesej (baris gilir mesej);

Mari kita lihat cara melaksanakan kaedah komunikasi ini dalam nod

1 Memori Dikongsi (perkongsian memori)

Pada satu mesin ( Benang tunggal dalam pelanggan, berbilang benang dalam satu proses, berbilang proses dalam pelayan tunggal), komunikasi melalui perkongsian memori adalah cara yang paling biasa.

Memori Dikongsi (perkongsian memori)-benang tunggal

Dari peringkat sistem pengendalian, semua memori utas dalam proses dikongsi, tetapi prasyaratnya ialah memori itu memerlukan untuk diketahui alamat akses.

Tetapi dari peringkat bahasa (peringkat pelaksanaan nod atau v8), kami tidak menyentuh pengurusan memori secara langsung, tetapi secara tidak langsung melaksanakan operasi memori daripada sintaks/api yang disediakan oleh v8. v8 memberi kita tiga cara untuk berkongsi memori (mungkin lebih sesuai dipanggil pembolehubah kongsi): pembolehubah global,

pembolehubah tempatan

,

parameter dikongsi

(panggilan dengan perkongsian) ; Sebelum melaksanakan kod, v8 akan menukar kod tersebut menjadi pokok sintaks abstrak melalui spesifikasi Estree dan kemudian mentafsir, menyusun dan melaksanakannya Dalam pokok sintaks abstrak (untuk pokok sintaks abstrak, sila lihat saya yang lain artikel), Terdapat skop, dan bacaan memori dilakukan dengan melihat kembali melalui pengecam (penamaan pembolehubah) langkah demi langkah. Jadi jika anda perlu berkongsi beberapa memori antara dua kaedah, anda boleh menciptanya dalam skop biasa mereka. Memori Dikongsi (perkongsian memori)-pelbagai benang

Dalam sama ada persekitaran klien atau persekitaran nod, kita boleh melaksanakan multi-threading, dan kedua-dua kaedah tersebut adalah serupa (nod melepasi pelaksanaan worker_threads, penyemak imbas melaksanakannya melalui Worker). Perkongsian memori di sini terutamanya dicapai dengan bantuan API operasi memori (SharedArrayBuffer). Mari kita lihat dahulu contoh pelaksanaan penyemak imbas:

Memori Dikongsi (perkongsian memori)-berbilang proses

Kerana memori tidak boleh membaca satu sama lain selepas proses dimulakan. (Sekatan di peringkat sistem) Perkongsian memori antara proses sebenarnya dicapai dengan membuka bahagian baru memori yang dikongsi. Walau bagaimanapun, nod tidak menyokong memori kongsi buat masa ini dan hanya boleh dilaksanakan melalui bahasa peringkat rendah, contohnya: pemalam addon shared-memory-disruptor yang dilaksanakan dalam c (diterangkan dalam artikel lain).

// 主线程
const buffer = new SharedArrayBuffer(1024)
const typedArr = new Int16Array(buffer)
const newWorker = new Worker('./worker.js')

typedArr[0] = 20

newWorker.postMessage(buffer)
newWorker.onmessage= (data) => {
    console.group('[the main thread]');
    console.log('Data received from the main thread: %i', typedArr[0]);
    console.groupEnd();
}
// 子线程
addEventListener('message', ({ data }) => {
  const arr = new Int16Array(data)

  console.group('[the worker thread]')
  console.log('Data received from the main thread: %i', arr[0])
  console.groupEnd()
  arr[0] = 18
  
  postMessage('Updated')
})
// 结果
[the worker thread]
  Data received from the main thread: 20
[the main thread]
  Data received from the main thread: 18

2. Soket (Soket) Soket dilaksanakan dalam dua cara:

1.

2 dua Perbezaannya adalah seperti berikut:

Soket TCP


Konsep: Soket TCP ialah lapisan abstraksi perantaraan untuk komunikasi antara lapisan aplikasi dan TCP/IP keluarga protokol, dan merupakan sistem pengendalian Mekanisme komunikasi antara proses yang disediakan; dalam pembangunan harian kami adalah pelbagai protokol lapisan aplikasi (http, websocket, rpc, ftp, dll.), modul http dalam nod juga dilaksanakan berdasarkan modul bersih.

TCP Socket适用于单机,C/S架构等.但UNIX Domain Socket只适用于单机。  
UNIX Domain Socket不需要经过一系列的网络中转(协议，分包，校验等等)，性能更高，稳定性更好。

Nota: Malah, UDP juga tergolong dalam lapisan TCP (tidak merujuk sepenuhnya kepada komunikasi TCP, tetapi lapisan TCP/IP dalam lapisan komunikasi rangkaian menyediakan modul 'dgram' untuk melaksanakannya). tetapi dalam praktiknya saya tidak pernah didedahkan kepadanya dalam aplikasi, jadi saya tidak tahu banyak tentangnya.

bersih

Dalam nod, Soket TCP dilaksanakan oleh modul bersih Modul bersih terutamanya menyediakan fungsi berikut:

1 Sokongan IPC (sebenarnya perlaksanaan komunikasi saluran paip, komunikasi saluran paip akan diterangkan secara terperinci kemudian); 🎜 >

Soket Domain UNIX

Soket Domain UNIX mencipta deskriptor fail dan berkomunikasi antara proses yang berbeza dengan membaca dan menulis deskriptor fail ini (boleh Ia dibahagikan kepada penciptaan proses dan proses lain Komunikasi bersama antara proses lain boleh melalui proses penciptaan sebagai transit). cth.

3. Talian Paip

Komunikasi saluran paip terbahagi kepada dua jenis, paip tidak bernama dan paip bernama.

Paip tidak dinamakan dilaksanakan dengan cara yang sama seperti Soket Domain UNIX, berkomunikasi dengan mencipta deskriptor fail.

// 服务端通过net.createServer创建服务，会返回net.Server对象，可以通过返回值进行各种事件监听，端口监听
const net = require('net')

net.createServer((server => {
  server.end(`hello world!\n`)
})).listen(3302, () => {
  console.log(`running ...`)
})

Paip bernama berkomunikasi melalui deskriptor fail tetap:

"\\\\.\\pipe\\" + PIPE_NAME;

源码可参考stackoverflow（https://stackoverflow.com/questions/11750041/how-to-create-a-named-pipe-in-node-js）
目前理解的管道通信和UNIX Domain Socket实现基本一致，只是管道通信规范了读写权限，半双工通信，UNIX Domain Socket更加自由一些。

四、Signal(信号)

Signal是操作系统在终止进程前给进程发送的信号。在node中可以通过process.kill(pid, signal)/child_process.kill(pid, signal)接口实现,e.g.

// 要被终止的http守护进程
const Koa = require('koa')
const app = new Koa()

app.listen(3004, () => {
  console.log(`process pid is : ${process.pid}`) // process pid is : 75208
})
// 操作进程
process.kill(75208, 'SIGHUP') // 'SIGHUP'是一般结束进程的信号，还有更多其他的信号参考 [标识](https://blog.csdn.net/houjixin/article/details/71430489)

但这里的前提是你需要获取到被终止的进程pid，更多pid的内容可阅读我之前关于进程的文章。

五、Message queue(消息队列)

一开始我以为是redis,各种MQ之类的基于TCP的消息队列。但其实是操作系统内的消息队列，node暂时没有提供相关的上层接口，需要更底层实现，e.g. svmq

更多node相关知识，请访问：nodejs 教程！！

Atas ialah kandungan terperinci Penjelasan terperinci tentang beberapa kaedah pelaksanaan komunikasi proses dalam nod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!