เรามาพูดถึงกระบวนการ เธรด โครูทีน และโมเดลการทำงานพร้อมกันใน Node.js กัน

ตอนนี้ Node.js กลายเป็นสมาชิกของกล่องเครื่องมือสำหรับการสร้างบริการแอปพลิเคชันเครือข่ายที่ทำงานพร้อมกันสูง เหตุใด Node.js จึงกลายเป็นที่รักของสาธารณชน บทความนี้จะเริ่มต้นด้วยแนวคิดพื้นฐานของกระบวนการ เธรด โครูทีน และโมเดล I/O และให้ข้อมูลเบื้องต้นที่ครอบคลุมเกี่ยวกับ Node.js และโมเดลการทำงานพร้อมกัน

กระบวนการ

โดยทั่วไปเราเรียกอินสแตนซ์ที่กำลังทำงานอยู่ของโปรแกรมว่ากระบวนการ เป็นหน่วยพื้นฐานสำหรับการจัดสรรทรัพยากรและกำหนดเวลาโดยระบบปฏิบัติการ โดยทั่วไปจะประกอบด้วยส่วนต่างๆ ต่อไปนี้:

• โปรแกรม: รหัสที่จะดำเนินการ ซึ่งใช้เพื่ออธิบายกระบวนการ ข้อกำหนด ฟังก์ชั่นที่สมบูรณ์
• พื้นที่ข้อมูลที่ประมวลผลโดยกระบวนการ รวมถึงข้อมูล หน่วยความจำที่จัดสรรแบบไดนามิก สแต็กผู้ใช้ของฟังก์ชันการประมวลผล โปรแกรมที่ปรับเปลี่ยนได้ และข้อมูลอื่น ๆ
• ในตาราง กระบวนการเพื่อนำโมเดลกระบวนการไปใช้ เรียกว่า เป็นตาราง进程表แต่ละกระบวนการครอบครองรายการ进程表项(หรือที่เรียกว่า进程控制块) รายการนี้ประกอบด้วยสถานะกระบวนการที่สำคัญ เช่น ตัวนับโปรแกรม ตัวชี้สแต็ก การจัดสรรหน่วยความจำ สถานะของไฟล์ที่เปิด และข้อมูลกำหนดการ ข้อมูลเพื่อให้แน่ใจว่าหลังจากกระบวนการถูกระงับระบบปฏิบัติการสามารถฟื้นฟูกระบวนการได้อย่างถูกต้อง

กระบวนการมีลักษณะดังต่อไปนี้:

• ความเป็นไดนามิก: สาระสำคัญของกระบวนการคือกระบวนการดำเนินการของโปรแกรมในระบบหลายโปรแกรม กระบวนการถูกสร้างและทำลายแบบไดนามิก การเกิดขึ้น
• พร้อมกัน: กระบวนการใด ๆ ที่สามารถดำเนินการพร้อมกันกับกระบวนการอื่น ๆ
• : กระบวนการเป็นหน่วยพื้นฐานที่สามารถทำงานได้อย่างอิสระ และยังเป็นหน่วยอิสระสำหรับการจัดสรรทรัพยากรและการกำหนดเวลาโดยระบบ
• ความไม่ตรงกัน: เนื่องจากข้อจำกัดร่วมกันระหว่างกระบวนการ กระบวนการจึงมีการดำเนินการเป็นระยะๆ นั่นคือ กระบวนการดำเนินการที่เป็นอิสระ และความเร็วที่คาดเดาไม่ได้ ดันไปข้างหน้า

ควรสังเกตว่าหากโปรแกรมถูกรันสองครั้ง แม้ว่าระบบปฏิบัติการจะสามารถเปิดใช้งานให้แชร์โค้ดได้ (เช่น มีโค้ดเพียงสำเนาเดียวเท่านั้นที่อยู่ในหน่วยความจำ) ก็ไม่สามารถเปลี่ยนแปลงได้ว่าทั้งสองอินสแตนซ์ของโปรแกรมที่รันอยู่นั้นแตกต่างกันสองรายการ ประมวลผลข้อเท็จจริง

ในระหว่างการดำเนินการกระบวนการ เนื่องจากสาเหตุหลายประการ เช่น การหยุดชะงักและการตั้งเวลา CPU กระบวนการจะสลับระหว่างสถานะต่อไปนี้:

• สถานะกำลังทำงาน: กระบวนการกำลังทำงานอยู่ในขณะนี้และครอบครอง CPU
• สถานะพร้อม: กระบวนการพร้อมและสามารถทำงานได้ตลอดเวลา แต่ถูกหยุดชั่วคราวเนื่องจากกระบวนการอื่นกำลังทำงานอยู่
• สถานะถูกบล็อก: กระบวนการถูกบล็อกในตอนนี้ เว้นแต่จะมีเหตุการณ์ภายนอก (เช่น ข้อมูลอินพุตจากแป้นพิมพ์มาถึง) เกิดขึ้น มิฉะนั้น กระบวนการจะไม่สามารถรันได้

จากแผนภาพการสลับสถานะกระบวนการด้านบน เราจะเห็นว่ากระบวนการสามารถเปลี่ยนจากสถานะกำลังทำงานเป็นสถานะพร้อมและสถานะถูกบล็อกได้ แต่มีเพียงสถานะพร้อมเท่านั้นที่สามารถเปลี่ยนเป็นสถานะกำลังทำงานได้โดยตรง เนื่องจาก:

• การเปลี่ยนจากสถานะกำลังทำงานเป็นสถานะพร้อม เกิดจากตัวกำหนดเวลากระบวนการ ใช่ เนื่องจากระบบคิดว่ากระบวนการปัจจุบันใช้เวลา CPU มากเกินไป และตัดสินใจที่จะปล่อยให้กระบวนการอื่นใช้เวลา CPU และตัวกำหนดเวลากระบวนการเป็นส่วนหนึ่งของระบบปฏิบัติการ และกระบวนการไม่ได้เกิดขึ้น แม้จะรู้สึกถึงการมีอยู่ของตัวกำหนดตารางเวลา
• มันเปลี่ยนจากสถานะการทำงานเป็นการบล็อก กระบวนการไม่สามารถดำเนินการต่อไปได้เนื่องจากเหตุผลของตัวเอง (เช่น กำลังรอการป้อนข้อมูลจากแป้นพิมพ์ของผู้ใช้) และสามารถหยุดและรอได้เฉพาะเหตุการณ์บางอย่างเท่านั้น (เช่น แป้นพิมพ์ ข้อมูลอินพุตมาถึงแล้ว) ที่จะเกิดขึ้น เมื่อมีเหตุการณ์ที่เกี่ยวข้องเกิดขึ้น กระบวนการจะถูกแปลงเป็นสถานะพร้อมใช้ก่อน หากไม่มีกระบวนการอื่นใดที่ทำงานอยู่ในขณะนี้ กระบวนการนั้นจะถูกแปลงเป็นสถานะกำลังทำงานทันที มิฉะนั้น กระบวนการจะยังคงอยู่ใน สถานะพร้อม กำลังรอการกำหนดเวลาโดยตัวกำหนดเวลากระบวนการ

เธรด

บางครั้งเราจำเป็นต้องใช้เธรดเพื่อแก้ไขปัญหาต่อไปนี้:

• เมื่อจำนวนกระบวนการเพิ่มขึ้น ค่าใช้จ่ายในการสลับระหว่างกระบวนการจะมากขึ้นเรื่อยๆ และการใช้งาน CPU อย่างมีประสิทธิภาพจะลดลงเรื่อยๆ ในกรณีที่ร้ายแรง ระบบอาจเสียหาย ปรากฏการณ์ต่างๆ เช่น แอนิเมชั่นที่ถูกระงับ
• แต่ละกระบวนการมีพื้นที่หน่วยความจำอิสระของตัวเอง และช่องว่างหน่วยความจำระหว่างกระบวนการก็แยกออกจากกัน งานบางอย่างอาจจำเป็นต้องแบ่งปันข้อมูลบางอย่าง และการซิงโครไนซ์ข้อมูลระหว่างหลายกระบวนการก็เช่นกัน ยุ่งยาก.

เกี่ยวกับเธรด เราจำเป็นต้องทราบประเด็นต่อไปนี้:

• เธรดคือโฟลว์ควบคุมลำดับเดียวในการทำงานของโปรแกรม เป็นหน่วยที่เล็กที่สุดที่ระบบปฏิบัติการสามารถดำเนินการกำหนดเวลาการคำนวณ ซึ่งรวมอยู่ในกระบวนการและเป็นหน่วยที่ทำงานอยู่จริง กระบวนการ
• สามารถมีหลายเธรด แต่ละเธรดดำเนินการงานที่แตกต่างกันพร้อมกัน
• เธรดทั้งหมดในกระบวนการแชร์พื้นที่หน่วยความจำของกระบวนการ (รวมถึงโค้ด ข้อมูล ฮีป ฯลฯ) และข้อมูลทรัพยากรบางอย่าง (เช่น ไฟล์ที่เปิดและ สัญญาณของระบบ)
• เธรดในกระบวนการหนึ่งไม่สามารถมองเห็นได้ในกระบวนการอื่น

ตอนนี้เราเข้าใจคุณลักษณะพื้นฐานของเธรดแล้ว เรามาพูดถึงประเภทเธรดทั่วไปหลายประเภทกันดีกว่า

เธรดสถานะเคอร์เนล เธรด

สถานะเคอร์เนลเป็นเธรดที่รองรับโดยตรงโดยระบบปฏิบัติการ มีดังต่อไปนี้:

• การสร้างเธรด การกำหนดเวลา การซิงโครไนซ์ และการทำลายเสร็จสิ้นโดยเคอร์เนลของระบบ แต่โอเวอร์เฮดนั้นมีราคาค่อนข้างแพง
• เคอร์เนลสามารถแมปเคอร์เนลได้ ระบุเธรดไปยังกระบวนการต่างๆ บนโปรเซสเซอร์ หนึ่งคอร์ของโปรเซสเซอร์สามารถเชื่อมโยงกับเธรดเคอร์เนลเดียวได้อย่างง่ายดาย ดังนั้นจึงแข่งขันกันอย่างเต็มที่และใช้ทรัพยากรของ CPU
• เท่านั้น สามารถเข้าถึงเฉพาะโค้ดและข้อมูลของคอร์เท่านั้นที่สามารถเข้าถึง
• การซิงโครไนซ์ทรัพยากรและการแบ่งปันข้อมูลได้ ต่ำกว่ากระบวนการ.

เธรดโหมดผู้ใช้ เธรด

โหมดผู้ใช้เป็นเธรดที่สร้างขึ้นอย่างสมบูรณ์ในพื้นที่ผู้ใช้ ดังนี้:

• การสร้างเธรด การกำหนดเวลา การซิงโครไนซ์ และการทำลายจะเสร็จสมบูรณ์โดยพื้นที่ผู้ใช้ และโอเวอร์เฮดนั้นต่ำมาก
• เนื่องจากเธรดโหมดผู้ใช้ ได้รับการดูแลโดยพื้นที่ผู้ใช้ เคอร์เนลไม่รับรู้การมีอยู่ของเธรดโหมดผู้ใช้ ดังนั้นเคอร์เนลจึงจัดตารางเวลาและจัดสรรทรัพยากรให้กับกระบวนการเท่านั้น การกำหนดเวลาและการจัดสรรทรัพยากรของเธรดในกระบวนการได้รับการจัดการโดย ตัวโปรแกรมเอง สิ่งนี้มีแนวโน้มที่จะทำให้เธรดโหมดผู้ใช้ถูกบล็อกในการเรียกของระบบ มีความเสี่ยงที่กระบวนการทั้งหมดจะถูกบล็อก
• สามารถเข้าถึงพื้นที่ที่อยู่ที่ใช้ร่วมกันและทรัพยากรระบบทั้งหมดของกระบวนการนั้น การ
• ประสานทรัพยากรและการแบ่งปันข้อมูลมีประสิทธิภาพมากขึ้น

กระบวนการน้ำหนักเบา (LWP)

กระบวนการน้ำหนักเบา (LWP) เป็นเธรดผู้ใช้ที่สร้างขึ้นและรองรับโดยเคอร์เนล คุณสมบัติหลักมีดังนี้:

• พื้นที่ผู้ใช้สามารถใช้เธรดเคอร์เนลผ่านกระบวนการน้ำหนักเบาเท่านั้น (LWP) เชื่อมโยงระหว่างเธรดโหมดผู้ใช้และเธรดเคอร์เนล ดังนั้น เฉพาะการสนับสนุนเธรดเคอร์เนลเท่านั้นที่จะมีกระบวนการแบบไลต์เวท (LWP)

• การดำเนินการส่วนใหญ่ของกระบวนการแบบไลต์เวท (LWP) ต้องการพื้นที่โหมดผู้ใช้เพื่อเริ่มต้นการเรียกระบบ มีราคาค่อนข้างแพง (ต้องสลับระหว่างโหมดผู้ใช้และโหมดเคอร์เนล)

• แต่ละกระบวนการแบบไลท์เวท (LWP) จำเป็นต้องเชื่อมโยงกับเคอร์เนลเธรดเฉพาะ ดังนั้น:

  • เช่นเดียวกับเคอร์เนลเธรด ทรัพยากรของ CPU สามารถแข่งขันและใช้งานทั่วทั้งระบบได้อย่าง
  • เต็มที่ กระบวนการ (LWP) เป็นหน่วยการกำหนดเวลาเธรดอิสระ ดังนั้นแม้ว่ากระบวนการแบบน้ำหนักเบา (LWP) จะถูกบล็อกในการเรียกของระบบ แต่ก็ไม่ส่งผลกระทบต่อการดำเนินการของกระบวนการทั้งหมด
  • กระบวนการแบบน้ำหนักเบา (LWP) จำเป็นต้องใช้ทรัพยากรเคอร์เนล (โดยหลักแล้ว) หมายถึงพื้นที่สแต็กของเคอร์เนลเธรด) ซึ่งทำให้ระบบไม่สามารถรองรับกระบวนการน้ำหนักเบาจำนวนมาก (LWP)

• พวกเขาสามารถเข้าถึงกระบวนการของตนเองได้ พื้นที่ที่อยู่ที่ใช้ร่วมกันและทรัพยากรระบบทั้งหมด

สรุป

ข้างต้น เราได้แนะนำประเภทเธรดทั่วไปโดยย่อ (เธรดสถานะเคอร์เนล เธรดสถานะผู้ใช้ กระบวนการแบบไลท์เวท) แต่ละรายการมีขอบเขตการใช้งานของตัวเอง คุณสามารถใช้งานได้อย่างอิสระตามความต้องการของคุณ การรวมกัน เช่น แบบตัวต่อตัวแบบทั่วไป แบบหลายต่อหนึ่ง แบบหลายต่อหลายแบบ และแบบอื่นๆ เนื่องจากข้อจำกัดด้านพื้นที่ บทความนี้จะไม่แนะนำเรื่องนี้มากนัก นักเรียนที่สนใจสามารถศึกษาได้ด้วยตนเอง

Coroutine

หรือที่เรียกว่า Fiber เป็นกลไกการทำงานของโปรแกรมที่สร้างขึ้นบนเธรดที่ช่วยให้นักพัฒนาสามารถจัดการกำหนดเวลาการดำเนินการ การบำรุงรักษาสถานะ และพฤติกรรมอื่น ๆ ได้ด้วยตัวเอง คุณสมบัติหลักคือ

• : การกำหนดตารางเวลาการดำเนินการไม่จำเป็นต้องมีการสลับบริบท ดังนั้นจึงมีประสิทธิภาพการดำเนินการที่ดี
• เนื่องจากทำงานบนเธรดเดียวกัน จึงไม่มีปัญหาในการซิงโครไนซ์ในการสื่อสารของเธรด
• จึงสะดวกในการสลับโฟลว์การควบคุม และทำให้โมเดลการเขียนโปรแกรมง่ายขึ้น

ใน JavaScript async/await ที่เรามักใช้คือการนำ coroutine ไปใช้ เช่นตัวอย่างต่อไปนี้:

function updateUserName(id, name) {
  ผู้ใช้ const = getUserById(id);
  user.updateName(ชื่อ);
  กลับเป็นจริง;
-

ฟังก์ชั่น async updateUserNameAsync (id, ชื่อ) {
  ผู้ใช้ const = รอ getUserById (id);
  รอ user.updateName (ชื่อ);
  กลับเป็นจริง;
}

ในตัวอย่างข้างต้น ลำดับการดำเนินการเชิงตรรกะภายในฟังก์ชัน updateUserName และ updateUserNameAsync คือ:

• เรียกใช้ฟังก์ชัน getUserById และกำหนดค่าส่งคืนให้กับ user ตัวแปร
• เรียกเมธอด updateName ของ user
• คืน true ให้กับผู้เรียก

ความแตกต่างที่สำคัญระหว่างทั้งสองอยู่ในการควบคุมสถานะระหว่างการดำเนินการจริง:

• ในระหว่างการดำเนินการของฟังก์ชัน updateUserName จะถูกดำเนินการตามลำดับตามลำดับตรรกะที่กล่าวถึงข้างต้น
• ในระหว่างการดำเนินการของฟังก์ชัน updateUserNameAsync ก็จะถูกดำเนินการตามลำดับตามลำดับเช่นกัน ลำดับตรรกะที่กล่าวถึงข้างต้น แต่เมื่อพบ await updateUserNameAsync จะถูกระงับและบันทึกสถานะของโปรแกรมปัจจุบันที่ตำแหน่งที่ถูกระงับ มันจะไม่ปลุก updateUserNameAsync อีกครั้งจนกว่าส่วนของโปรแกรมหลังจาก await ส่งคืนและกู้คืนสถานะของโปรแกรมก่อนที่จะหยุดชั่วคราว แล้วไปต่อที่โปรแกรมถัดไป

จากการวิเคราะห์ข้างต้น เราสามารถเดาได้อย่างกล้าหาญ: สิ่งที่ Coroutines จำเป็นต้องแก้ไขไม่ใช่ปัญหาการทำงานพร้อมกันของโปรแกรมที่กระบวนการและเธรดจำเป็นต้องแก้ไข แต่เป็นปัญหาที่พบเมื่อประมวลผลงานแบบอะซิงโครนัส (เช่น การทำงานของไฟล์ การร้องขอเครือข่าย ฯลฯ ); ใน ก่อน async/await เราสามารถจัดการงานแบบอะซิงโครนัสผ่านฟังก์ชันการโทรกลับเท่านั้น ซึ่งอาจทำให้เราตกอยู่ใน回调地狱และสร้างโค้ดที่ยุ่งเหยิงซึ่งโดยทั่วไปแล้วยากต่อการบำรุงรักษา ผ่าน coroutines เราสามารถบรรลุวัตถุประสงค์ของการซิงโครไนซ์โค้ด .

สิ่งที่ต้องจำไว้คือความสามารถหลักของโครูทีนคือสามารถระงับบางโปรแกรมและรักษาสถานะของตำแหน่งการระงับของโปรแกรม และกลับมาทำงานต่อที่ตำแหน่งที่ถูกระงับในเวลาใดเวลาหนึ่งในอนาคต และดำเนินการต่อ ดำเนินการส่วนถัดไปหลังจากโปรแกรมช่วงล่าง

โมเดล I/O

การดำเนินการ I/O ที่สมบูรณ์จะต้องผ่านขั้นตอนต่อไปนี้:

• กระบวนการผู้ใช้ (เธรด) เริ่มต้นคำขอการดำเนินการ I/O ไปยังเคอร์เนลผ่านการเรียกของระบบ;
• เคอร์เนลประมวลผลคำขอการดำเนินการ I/O (แบ่งออกเป็น เข้าสู่ขั้นตอนการเตรียมการและขั้นตอนการดำเนินการจริง) และส่งคืนผลลัพธ์การประมวลผลไปยังเธรดผู้ใช้

เราสามารถแบ่งการดำเนินการ I/O ออกเป็นสี่ประเภทโดยประมาณ:阻塞I/O ,非阻塞I/O ,同步I/O และ异步I/O ก่อนที่จะพูดถึงประเภทเหล่านี้ ก่อนอื่นเราจะทำความคุ้นเคยกับสองชุดต่อไปนี้ แนวคิด (ในที่นี้ สมมติว่าบริการ A เรียกใช้บริการ B):

• 阻塞/非阻塞:

  • หาก A กลับมาหลังจากได้รับคำตอบจาก B เท่านั้น การโทรนั้นจะ阻塞调用
  • ถ้า A กลับมาทันทีหลังจากการโทร B (นั่นคือ มี ไม่จำเป็นต้องรอให้ B ดำเนินการให้เสร็จสิ้น) จากนั้นการโทรจะเป็นการ非阻塞调用

• 同步/异步:

  • ถ้า B แจ้งเตือน A หลังจากดำเนินการเสร็จสิ้นแล้ว บริการ B จะเป็น同步
  • ถ้า A เรียก B, B จะแจ้งเตือน A ทันทีว่าได้รับคำขอแล้วจึงดำเนินการผ่าน回调หลังจากการดำเนินการเสร็จสิ้น ผลลัพธ์จะได้รับแจ้งไปยัง A จากนั้นบริการ B จะเป็น异步

หลายๆ คนมักสับสนระหว่าง阻塞/非阻塞กับ同步/异步ดังนั้นจึงจำเป็นต้องให้ความสนใจเป็นพิเศษ:

• 阻塞/非阻塞มีไว้สำหรับ调用者บริการ ส่วน
• 同步/异步มีไว้สำหรับ被调用者บริการ

หลังจากทำความเข้าใจ阻塞/非阻塞และ同步/异步แล้ว เรามาดู I/O 模型ที่เฉพาะเจาะจงกัน

การบล็อกคำจำกัดความของ I/O

: หลังจากที่เธรดผู้ใช้เริ่มต้นการเรียกระบบ I/O เธรดผู้ใช้จะ阻塞ทันทีจนกว่าการดำเนินการ I/O ทั้งหมดจะได้รับการประมวลผล และผลลัพธ์จะถูกส่งกลับไปยังเธรดผู้ใช้ หลังจากที่ผู้ใช้เข้าสู่เท่านั้น (เธรด) กระบวนการสามารถปล่อยสถานะ阻塞และดำเนินการดำเนินการต่อไปได้

คุณสมบัติ:

• เนื่องจากโมเดลนี้จะบล็อกกระบวนการ (เธรด) ของผู้ใช้ จึงไม่ได้ใช้ทรัพยากรของ CPU
• เมื่อดำเนินการ I/O กระบวนการของผู้ใช้ (เธรด) จึงไม่สามารถทำการดำเนินการอื่นได้
• โมเดลนี้เหมาะสำหรับแอปพลิเคชันที่ทำงานพร้อมกันขนาดเล็กเท่านั้น เนื่องจากคำขอ I/O หนึ่งคำขอสามารถบล็อกเธรดขาเข้า (เธรด) ได้ ดังนั้นเพื่อที่จะตอบสนองต่อคำขอ I/O ได้ทันเวลา จึงจำเป็นต้องจัดสรรเธรดขาเข้า (เธรด) ให้กับแต่ละคำขอ ซึ่งจะทำให้เกิดทรัพยากรจำนวนมาก การใช้งาน และสำหรับการร้องขอการเชื่อมต่อที่ยาวนาน เนื่องจากทรัพยากร (เธรด) ขาเข้าไม่สามารถเผยแพร่ได้เป็นเวลานาน หากมีคำขอใหม่ในอนาคต ปัญหาคอขวดด้านประสิทธิภาพที่ร้ายแรงจะเกิดขึ้น

I/O ที่ไม่บล็อก

:

• หลังจากที่ผู้ใช้เริ่มต้นการเรียกระบบ I/O ในเธรด (เธรด) หากการดำเนินการ I/O ไม่พร้อม การเรียก I/O จะส่งคืนข้อผิดพลาด และผู้ใช้ไม่ จำเป็นต้องเข้าสู่เธรด (เธรด) รอ แต่ใช้การโพลเพื่อตรวจสอบว่าการดำเนินการ I/O พร้อมหรือไม่
• หลังจากการดำเนินการพร้อมแล้ว การดำเนินการ I/O จริงจะบล็อกเธรดของผู้ใช้จนกว่าผลการดำเนินการจะถูกส่งกลับไปยัง เธรดของผู้ใช้

คุณลักษณะ:

• เนื่องจากโมเดลนี้ต้องการให้ผู้ใช้สอบถามเกี่ยวกับสถานะความพร้อมในการดำเนินการ I/O อย่างต่อเนื่อง (โดยปกติจะใช้การวนซ้ำ while ) ผู้ใช้จึงต้องใช้โมเดลนี้และใช้ทรัพยากรของ CPU
• ก่อนที่การดำเนินการ I/O จะพร้อม จำเป็นต้องป้อน (เธรด) จะไม่ถูกบล็อก เมื่อการดำเนินการ I/O พร้อม การดำเนินการ I/O จริงที่ตามมาจะบล็อกผู้ใช้ไม่ให้เข้าสู่เธรด (เธรด
• ) เกิดขึ้นพร้อมกันเล็กน้อยและไม่ต้องการการตอบสนองอย่างทันท่วงที

I/O แบบซิงโครนัส

นัส) หลังจากที่กระบวนการผู้ใช้ (เธรด) เริ่มต้นการเรียกระบบ I/O หากการเรียก I/O ทำให้กระบวนการผู้ใช้ (เธรด) ถูกบล็อก ดังนั้นการเรียก I/O จะเป็น同步I/O นัส同步I/O ฉะนั้นจะเป็น异步I/O

เกณฑ์สำหรับการตัดสินว่าการดำเนินการ I/O同步หรือ异步นั้นเป็นกลไกการสื่อสารระหว่างเธรดผู้ใช้และการดำเนินการ I/O ใน

• กรณีของ同步การโต้ตอบระหว่างเธรดผู้ใช้และ I/O จะถูกซิงโครไนซ์ผ่านเคอร์เนลบัฟเฟอร์ นั่นคือเคอร์เนลจะซิงโครไนซ์ผลการดำเนินการของการดำเนินการ I/O ไปยังบัฟเฟอร์ จากนั้นคัดลอกข้อมูลในบัฟเฟอร์ไปยังเธรดผู้ใช้ กระบวนการนี้จะบล็อกเธรดผู้ใช้จนกว่าการดำเนินการ I/O จะเสร็จสมบูรณ์
• ใน异步สถานการณ์ การโต้ตอบระหว่างเธรดผู้ใช้ (เธรด) และ I/O จะถูกซิงโครไนซ์โดยตรงผ่านเคอร์เนล นั่นคือ เคอร์เนลจะคัดลอกผลการดำเนินการของการดำเนินการ I/O ไปยังเธรดผู้ใช้ (เธรด) โดยตรง ไม่บล็อกกระบวนการ (เธรด) ของผู้ใช้

โมเดลการทำงานพร้อมกันของ Node.js

Node.js ใช้โมเดล I/O แบบอะซิงโครนัสแบบเธรดเดียวที่ขับเคลื่อนด้วยเหตุการณ์ โดยส่วนตัวแล้ว ฉันคิดว่าเหตุผลในการเลือกโมเดลนี้คือ:

• JavaScript ทำงานในโหมดเธรดเดี่ยวภายใต้ V8 ซึ่งใช้งานหลายรายการ เธรดนั้นยากมาก
• แอปพลิเคชันเครือข่ายส่วนใหญ่ต้องใช้ I/O มาก วิธีการจัดการทรัพยากรแบบมัลติเธรดอย่างสมเหตุสมผลและมีประสิทธิภาพ ขณะเดียวกันก็ทำให้มั่นใจว่าการทำงานพร้อมกันในระดับสูงนั้นซับซ้อนกว่าการจัดการทรัพยากรแบบเธรดเดียว

กล่าวโดยสรุป เพื่อจุดประสงค์ของความเรียบง่ายและมีประสิทธิภาพ Node.js ใช้โมเดล I/O แบบอะซิงโครนัสแบบเธรดเดียวที่ขับเคลื่อนด้วยเหตุการณ์ และใช้โมเดลผ่าน EventLoop ของเธรดหลักและเธรดตัวทำงานเสริม:

• After the Node กระบวนการ js เริ่มต้นแล้ว เธรดหลักของ Node.js จะสร้าง EventLoop ฟังก์ชันหลักของ EventLoop คือการลงทะเบียนฟังก์ชันการโทรกลับของเหตุการณ์และดำเนินการในลูปเหตุการณ์ในอนาคต
• เธรด Worker ใช้เพื่อดำเนินงานกิจกรรมเฉพาะ (เธรดอื่นที่ไม่ใช่เธรดหลัก) (ดำเนินการในลักษณะซิงโครนัส) จากนั้นส่งคืนผลลัพธ์การดำเนินการไปที่ EventLoop ของเธรดหลัก เพื่อให้ EventLoop สามารถดำเนินการฟังก์ชันเรียกกลับของเหตุการณ์ที่เกี่ยวข้องได้

ควรสังเกตว่า Node.js ไม่เหมาะสำหรับการทำงานที่ใช้ CPU มาก (เช่น ต้องใช้การคำนวณจำนวนมาก) เนื่องจากโค้ด EventLoop และ JavaScript (โค้ดงานเหตุการณ์ที่ไม่ตรงกัน) ทำงานในเธรดเดียวกัน (เช่น เธรดหลัก) และรายการใดรายการหนึ่ง หากทำงานนานเกินไป อาจทำให้เธรดหลักบล็อกได้ หากแอปพลิเคชันมีงานจำนวนมากที่ต้องใช้การดำเนินการนาน ก็จะลดปริมาณงานของเซิร์ฟเวอร์และอาจถึงขั้นนั้นด้วยซ้ำ ทำให้เซิร์ฟเวอร์ไม่ตอบสนอง

สรุป

Node.js เป็นเทคโนโลยีที่นักพัฒนาส่วนหน้าต้องเผชิญทั้งในปัจจุบันและในอนาคต อย่างไรก็ตาม นักพัฒนาส่วนหน้าส่วนใหญ่มีความรู้เพียงผิวเผินเกี่ยวกับ Node.js เท่านั้น เพื่อให้ทุกคนเข้าใจรูปแบบการทำงานพร้อมกันของ Node ได้ดีขึ้น .js บทความนี้จะแนะนำกระบวนการ เธรด และโครูทีนเป็นอันดับแรก จากนั้นจะแนะนำโมเดล I/O ต่างๆ และสุดท้ายจะให้ข้อมูลเบื้องต้นสั้นๆ เกี่ยวกับโมเดลการทำงานพร้อมกันของ Node.js แม้ว่าจะมีพื้นที่ไม่มากพอที่จะแนะนำโมเดลการทำงานพร้อมกันของ Node.js แต่ผู้เขียนเชื่อว่าไม่สามารถแยกออกจากหลักการพื้นฐานได้ การเรียนรู้พื้นฐานที่เกี่ยวข้อง จากนั้นทำความเข้าใจอย่างลึกซึ้งเกี่ยวกับการออกแบบและการใช้งาน Node.js จะได้รับผลลัพธ์สองเท่า ด้วยความพยายามครึ่งหนึ่ง

สุดท้ายนี้ หากมีข้อผิดพลาดใดๆ ในบทความนี้ ฉันหวังว่าคุณจะสามารถแก้ไขได้ ฉันหวังว่าทุกคนจะมีความสุขกับการเขียนโค้ดทุกๆ วัน