Mari kita bicara tentang proses, thread, coroutine, dan model konkurensi di Node.js

Node.js kini telah menjadi anggota toolbox untuk membangun layanan aplikasi jaringan konkurensi tinggi. Mengapa Node.js menjadi kesayangan masyarakat? Artikel ini akan dimulai dengan konsep dasar proses, thread, coroutine, dan model I/O, serta memberi Anda pengenalan komprehensif tentang Node.js dan model konkurensi.

Proses

Biasanya kita menyebut program yang sedang berjalan sebagai proses. Ini adalah unit dasar untuk alokasi sumber daya dan penjadwalan oleh sistem operasi. Biasanya mencakup bagian-bagian berikut:

• Program: kode yang akan dieksekusi, yang digunakan untuk menjelaskan proses persyaratan. Fungsi yang diselesaikan;
• area data: ruang data yang diproses oleh proses, termasuk data, memori yang dialokasikan secara dinamis, tumpukan fungsi pemrosesan pengguna, program yang dapat dimodifikasi, dan
• item tabel proses lainnya: untuk mengimplementasikan model proses, sistem operasi memelihara a disebut Ini adalah tabel进程表. Setiap proses menempati进程表项(juga disebut进程控制块). Entri ini berisi status proses penting seperti penghitung program, penunjuk tumpukan, alokasi memori, status file terbuka, dan informasi penjadwalan .informasi untuk memastikan bahwa setelah proses dihentikan, sistem operasi dapat menghidupkan kembali proses dengan benar.

Proses tersebut memiliki ciri-ciri sebagai berikut:

• Dinamis: Hakikat suatu proses adalah proses eksekusi suatu program dalam sistem multi-pemrograman. Proses dihasilkan dan dimusnahkan secara dinamis;
• Konkurensi: Setiap proses dapat dijalankan secara bersamaan dengan proses lainnya
• ; proses adalah unit dasar yang dapat berjalan secara independen, dan juga merupakan unit independen untuk alokasi sumber daya dan penjadwalan oleh sistem:
• karena adanya kendala timbal balik antar proses, proses tersebut memiliki eksekusi yang terputus-putus, yaitu proses dijalankan secara independen. dan kecepatan tak terduga Dorong ke depan.

Perlu dicatat bahwa jika suatu program dijalankan dua kali, bahkan jika sistem operasi dapat memungkinkan mereka untuk berbagi kode (yaitu hanya satu salinan kode yang ada di memori), hal ini tidak dapat mengubah bahwa dua contoh dari program yang sedang berjalan adalah dua hal yang berbeda. fakta proses.

Selama eksekusi proses, karena berbagai alasan seperti gangguan dan penjadwalan CPU, proses akan beralih antara status berikut:

• Running state: Proses sedang berjalan pada saat ini dan menempati CPU;
Ready
• state
• : Proses sudah siap dan dapat dijalankan kapan saja, namun dihentikan sementara karena proses lain sedang berjalan;
• saat ini, kecuali suatu peristiwa eksternal (seperti data input keyboard telah tiba) terjadi, jika tidak, proses tidak akan dapat berjalan.

Dari diagram peralihan status proses di atas terlihat bahwa suatu proses dapat berpindah dari status berjalan ke status siap dan status diblokir, namun hanya status siap yang dapat langsung dialihkan ke status berjalan. Hal ini karena:

• peralihan dari status berjalan ke status siap disebabkan oleh penjadwal proses. Ya, karena sistem menganggap proses saat ini memakan terlalu banyak waktu CPU dan memutuskan untuk membiarkan proses lain menggunakan waktu CPU; bahkan merasakan keberadaan penjadwal;
• ia beralih dari status berjalan ke pemblokiran. Proses tidak dapat melanjutkan eksekusi karena alasannya sendiri (seperti menunggu input keyboard pengguna), dan hanya dapat hang dan menunggu peristiwa tertentu (seperti keyboard). data input telah tiba) terjadi; ketika peristiwa terkait terjadi, proses terlebih dahulu diubah ke keadaan siap, jika tidak ada proses lain yang berjalan saat ini, maka akan segera diubah ke keadaan berjalan, jika tidak, proses akan tetap dalam keadaan berjalan keadaan siap, menunggu penjadwalan oleh penjadwal proses.

Threads

Terkadang, kita perlu menggunakan thread untuk memecahkan masalah berikut:

• Ketika jumlah proses meningkat, biaya peralihan antar proses akan menjadi semakin besar, dan penggunaan efektif CPU akan menjadi semakin rendah. sistem mungkin rusak. Fenomena seperti mati suri;
• setiap proses memiliki ruang memori independennya sendiri, dan ruang memori antar proses diisolasi satu sama lain. Beberapa tugas mungkin perlu berbagi beberapa data, dan sinkronisasi data antara beberapa proses juga banyak.

Mengenai thread, kita perlu mengetahui hal-hal berikut:

• Thread adalah aliran kontrol berurutan tunggal dalam eksekusi program. Ini adalah unit terkecil di mana sistem operasi dapat melakukan penjadwalan perhitungan. Ini termasuk dalam proses dan merupakan unit berjalan yang sebenarnya proses;
• suatu proses Ini dapat berisi banyak utas, setiap utas menjalankan tugas berbeda secara paralel,
• semua utas dalam suatu proses berbagi ruang memori proses (termasuk kode, data, tumpukan, dll.) dan beberapa informasi sumber daya (seperti file yang terbuka dan sinyal sistem);
• Thread dalam satu proses tidak terlihat dalam proses lainnya.

Sekarang setelah kita memahami karakteristik dasar thread, mari kita bahas beberapa jenis thread umum.

Thread status kernel

Thread status kernel adalah thread yang didukung langsung oleh sistem operasi. Fitur utamanya adalah sebagai berikut:

• pembuatan thread, penjadwalan, sinkronisasi, dan penghancuran diselesaikan oleh kernel sistem, tetapi overhead-nya relatif mahal
• ; menyatakan thread ke berbagai proses pada prosesor, satu inti prosesor dapat dengan mudah berhubungan dengan satu thread kernel, sehingga sepenuhnya bersaing untuk mendapatkan dan memanfaatkan sumber daya CPU
yang hanya dapat diakses oleh kode dan
• data
• inti;
• lebih rendah dibandingkan proses.

Utas mode pengguna

Utas mode pengguna adalah utas yang sepenuhnya dibangun di ruang pengguna. Karakteristik utamanya adalah sebagai berikut:

• pembuatan utas, penjadwalan, sinkronisasi, dan penghancuran diselesaikan oleh ruang pengguna, dan overhead-nya sangat rendah
• karena utas mode pengguna Dikelola oleh ruang pengguna, kernel tidak keberadaan thread mode pengguna tidak dirasakan, sehingga kernel hanya menjadwalkan dan mengalokasikan sumber daya ke proses yang dimilikinya. Penjadwalan dan alokasi sumber daya thread dalam proses ditangani oleh program itu sendiri. Hal ini mungkin menyebabkan thread mode pengguna diblokir dalam panggilan sistem, ada risiko bahwa seluruh proses akan diblokir;
• ia dapat mengakses semua ruang alamat bersama dan sumber daya sistem dari proses yang dimilikinya untuk;
• sinkronisasi sumber daya dan berbagi data lebih efisien.

Proses Ringan (LWP)

Proses ringan (LWP) adalah thread pengguna yang dibangun dan didukung oleh kernel. Fitur utamanya adalah sebagai berikut:

• Ruang pengguna hanya dapat menggunakan thread kernel melalui proses ringan (LWP). menjembatani antara thread mode pengguna dan thread kernel. Oleh karena itu, hanya dengan mendukung thread kernel barulah terdapat proses ringan (LWP).

• Sebagian besar operasi proses ringan (LWP) memerlukan ruang mode pengguna untuk memulai sistem relatif mahal (memerlukan peralihan antara mode pengguna dan mode kernel);

• setiap proses ringan (LWP) perlu dikaitkan dengan thread kernel tertentu, oleh karena itu:

  • seperti
  • thread kernel, sumber daya CPU dapat sepenuhnya dikompetisikan dan dimanfaatkan di seluruh sistem;
  • proses (LWP) adalah unit penjadwalan thread independen, jadi meskipun proses ringan (LWP) diblokir dalam panggilan sistem, Ini tidak mempengaruhi eksekusi seluruh
  • proses ringan (LWP) perlu menggunakan sumber daya kernel (terutama mengacu pada ruang tumpukan utas kernel), yang membuat sistem tidak mungkin mendukung sejumlah besar proses ringan (LWP);

• mereka dapat mengakses proses mereka sendiri Semua ruang alamat dan sumber daya sistem bersama;

Ringkasan

Di atas, kami secara singkat memperkenalkan jenis thread umum (thread status kernel, thread status pengguna, proses ringan). Masing-masing memiliki cakupan penerapannya sendiri, Anda dapat dengan bebas menggunakannya sesuai dengan kebutuhan Anda kombinasi, seperti model umum satu-ke-satu, banyak-ke-satu, banyak-ke-banyak dan lainnya. Karena keterbatasan ruang, artikel ini tidak akan memperkenalkan terlalu banyak tentang hal ini.

Coroutine

, juga disebut Fiber, adalah mekanisme berjalan program yang dibangun di atas thread yang memungkinkan pengembang mengelola sendiri penjadwalan eksekusi, pemeliharaan status, dan perilaku lainnya. Fitur utamanya adalah

• : Penjadwalan eksekusi tidak memerlukan peralihan konteks, sehingga memiliki efisiensi eksekusi yang baik;
• karena berjalan pada thread yang sama, tidak ada masalah sinkronisasi dalam komunikasi thread;
• akan lebih mudah untuk mengganti aliran kontrol dan menyederhanakan model pemrograman.

Pada JavaScript, async/await yang sering kita gunakan merupakan implementasi dari coroutine, seperti contoh berikut:

function updateUserName(id, name) {
  const pengguna = getUserById(id);
  pengguna.updateName(nama);
  kembali benar;
}

fungsi async updateUserNameAsync(id, nama) {
  const pengguna = menunggu getUserById(id);
  menunggu pengguna.updateName(nama);
  kembali benar;
}

Dalam contoh di atas, urutan eksekusi logis dalam fungsi updateUserName dan updateUserNameAsync adalah:

memanggil fungsi
• true
• getUserById menetapkan nilai kembaliannya ke variabel user ;
• memanggil metode updateName dari user ;

Perbedaan utama antara keduanya terletak pada kontrol status selama operasi sebenarnya:

• selama eksekusi fungsi updateUserName , ini dijalankan secara berurutan sesuai dengan urutan logis yang disebutkan di atas;
• selama eksekusi fungsi updateUserNameAsync , itu juga dijalankan secara berurutan sesuai dengan urutan logis yang disebutkan di atas, tetapi ketika bertemu await , updateUserNameAsync akan ditangguhkan dan menyimpan status program saat ini di lokasi yang ditangguhkan. Ini tidak akan membangunkan updateUserNameAsync lagi hingga fragmen program setelah await kembali dan memulihkan status program sebelum ditangguhkan, lalu Lanjutkan ke program berikutnya.

Dari analisis di atas, kita dapat dengan berani menebak: Yang perlu dipecahkan oleh coroutine bukanlah masalah konkurensi program yang perlu diselesaikan oleh proses dan thread, tetapi masalah yang dihadapi saat memproses tugas asinkron (seperti operasi file, permintaan jaringan, dll.); di Sebelum async/await , kita hanya dapat menangani tugas-tugas asinkron melalui fungsi panggilan balik, yang dapat dengan mudah membuat kita jatuh ke dalam回调地狱dan menghasilkan kode yang berantakan yang umumnya sulit dipertahankan. Melalui coroutine, kita dapat mencapai sinkronisasi kode asinkron .

Yang perlu diingat adalah bahwa kemampuan inti coroutine adalah mampu menangguhkan program tertentu dan mempertahankan status posisi penangguhan program, dan melanjutkannya pada posisi penangguhan di masa mendatang, dan melanjutkannya. jalankan segmen berikutnya setelah program suspensi.

Model I/O

Operasi I/O yang lengkap harus melalui tahapan berikut:

• proses pengguna (utas) memulai permintaan operasi I/O ke kernel melalui panggilan sistem;
• kernel memproses permintaan operasi I/O (dibagi ke dalam tahap persiapan dan tahap eksekusi sebenarnya), dan mengembalikan hasil pemrosesan ke thread pengguna.

Secara kasar kita dapat membagi operasi I/O menjadi empat jenis:阻塞I/O ,非阻塞I/O ,同步I/O , dan异步I/O Sebelum membahas jenis-jenis ini, pertama-tama kita kenali dua rangkaian berikut ini konsep (di sini Asumsikan bahwa layanan A memanggil layanan B):

• 阻塞/非阻塞:

  • Jika A kembali hanya setelah menerima respons dari B, maka panggilan tersebut adalah阻塞调用;
  • jika A kembali segera setelah panggilan B (yaitu, ada tidak perlu menunggu B menyelesaikan eksekusi), maka panggilan tersebut adalah非阻塞调用.

• 同步/异步:

  • Jika B memberi tahu A hanya setelah eksekusi selesai, maka layanan B同步;
  • jika A memanggil B, B segera memberi tahu A bahwa permintaan telah diterima, dan kemudian mengeksekusinya melalui回调setelah eksekusi selesai . Hasilnya diberitahukan ke A, maka layanan B bersifat异步.

Banyak orang sering mengacaukan阻塞/非阻塞dengan同步/异步, sehingga perhatian khusus perlu diberikan:

• 阻塞/非阻塞adalah untuk调用者layanan;
• 同步/异步adalah untuk被调用者layanan.

Setelah memahami阻塞/非阻塞dan同步/异步, mari kita lihat I/O 模型spesifiknya.

Memblokir definisi I/O

: Setelah thread pengguna memulai panggilan sistem I/O , thread pengguna akan segera阻塞hingga seluruh operasi I/O diproses dan hasilnya dikembalikan ke thread pengguna (utas) proses dapatkah status阻塞dilepaskan dan terus melakukan operasi selanjutnya.

Fitur:

• Karena model ini akan memblokir proses (utas) pengguna, model ini tidak menggunakan sumber daya CPU;
• saat melakukan operasi I/O , proses (utas) pengguna tidak dapat melakukan operasi lain;
• model ini hanya cocok untuk Aplikasi konkurensi kecil, ini karena satu permintaan I/O dapat memblokir thread (utas) masuk, jadi untuk merespons permintaan I/O tepat waktu, perlu mengalokasikan thread (utas) masuk untuk setiap permintaan, yang akan menyebabkan sumber daya yang sangat besar penggunaan , dan untuk permintaan koneksi yang lama, karena sumber daya (utas) yang masuk tidak dapat dilepaskan untuk waktu yang lama, jika ada permintaan baru di masa mendatang, akan terjadi hambatan kinerja yang serius.

Definisi

I/O non-pemblokiran

• Setelah pengguna memulai panggilan sistem I/O di thread (utas), jika operasi I/O belum siap, panggilan I/O akan mengembalikan kesalahan, dan pengguna tidak perlu memasukkan thread (utas). Tunggu, tetapi gunakan polling untuk mendeteksi apakah operasi I/O siap
• , operasi I/O yang sebenarnya akan memblokir thread pengguna hingga hasil eksekusi dikembalikan ke benang pengguna.

Fitur:

• Karena model ini mengharuskan pengguna untuk terus menanyakan status kesiapan operasi I/O (biasanya menggunakan loop while ), model perlu menempati CPU dan menggunakan sumber daya CPU
• sebelum operasi I/O siap, pengguna perlu memasukkan (Utas) utas tidak akan diblokir. Ketika operasi I/O siap, operasi I/O aktual selanjutnya akan memblokir pengguna untuk memasuki utas (utas);
• model ini hanya cocok untuk aplikasi dengan a sejumlah kecil konkurensi dan yang tidak memerlukan respons tepat waktu.

I/O Sinkron (asinkron)

Setelah proses pengguna (utas) memulai panggilan sistem I/O , jika panggilan I/O menyebabkan proses pengguna (utas) diblokir, maka panggilan I/O adalah同步I/O jika tidak, itu adalah异步I/O .

Kriteria untuk menilai apakah operasi I/O同步atau异步adalah mekanisme komunikasi antara thread pengguna dan operasi I/O . Dalam

• kasus同步, interaksi antara thread pengguna dan I/O disinkronkan melalui buffer kernel. yaitu, kernel akan menyinkronkan hasil eksekusi operasi I/O ke buffer, dan kemudian menyalin data di buffer ke thread pengguna. Proses ini akan memblokir thread pengguna hingga operasi I/O Selesai
• 异步situasi, interaksi antara thread pengguna (thread) dan I/O langsung disinkronkan melalui kernel, yaitu kernel akan langsung menyalin hasil eksekusi operasi I/O ke thread pengguna (thread). tidak Memblokir proses (utas) pengguna.

Model konkurensi Node.js

Node.js menggunakan model I/O asinkron berbasis peristiwa berulir tunggal. Secara pribadi, menurut saya alasan memilih model ini adalah:

• JavaScript berjalan dalam mode berulir tunggal di bawah V8, yang mengimplementasikan banyak hal. Thread sangatlah sulit;
• sebagian besar aplikasi jaringan bersifat intensif I/O . Cara mengelola sumber daya multi-thread secara wajar dan efisien sambil memastikan konkurensi tinggi lebih rumit daripada pengelolaan sumber daya single-thread.

Singkatnya, untuk tujuan kesederhanaan dan efisiensi, Node.js mengadopsi model I/O asinkron berbasis peristiwa berulir tunggal, dan mengimplementasikan modelnya melalui EventLoop dari thread utama dan thread Pekerja tambahan:

• Setelah Node.js. js dimulai, thread utama Node.js akan membuat EventLoop. Fungsi utama EventLoop adalah untuk mendaftarkan fungsi panggilan balik acara dan menjalankannya di loop acara mendatang
• ; (utas lain selain utas utama) (dieksekusi secara sinkron), lalu mengembalikan hasil eksekusi ke EventLoop dari utas utama, sehingga EventLoop dapat menjalankan fungsi panggilan balik dari peristiwa yang relevan.

Perlu dicatat bahwa Node.js tidak cocok untuk melakukan tugas-tugas yang intensif CPU (yaitu memerlukan banyak perhitungan); ini karena EventLoop dan kode JavaScript (kode tugas peristiwa non-asinkron) berjalan di thread yang sama (yaitu, thread utama), dan salah satunya Jika dijalankan terlalu lama, hal ini dapat menyebabkan thread utama diblokir. Jika aplikasi berisi banyak tugas yang memerlukan eksekusi lama, hal ini akan mengurangi throughput server dan bahkan mungkin menyebabkan server menjadi tidak responsif.

Ringkasan

Node.js adalah teknologi yang harus dihadapi oleh pengembang front-end saat ini dan bahkan di masa depan. Namun, sebagian besar pengembang front-end hanya memiliki pengetahuan dangkal tentang Node.js agar semua orang lebih memahami model konkurensi Node .js, Artikel ini pertama-tama memperkenalkan proses, thread, dan coroutine, kemudian memperkenalkan model I/O yang berbeda, dan terakhir memberikan pengenalan singkat tentang model konkurensi Node.js. Meskipun tidak banyak ruang untuk memperkenalkan model konkurensi Node.js, penulis yakin bahwa hal tersebut tidak pernah lepas dari prinsip dasar. Menguasai dasar-dasar yang relevan dan kemudian memahami secara mendalam desain dan implementasi Node.js akan mendapatkan hasil dua kali lipat dengan setengah usaha.

Terakhir, jika ada kesalahan pada artikel ini, saya harap Anda dapat memperbaikinya. Saya berharap Anda semua senang coding setiap hari.