การเขียนโปรแกรมซิงค์ / Async

หากผู้โทรส่งข้อความถึงผู้รับและกำลังรอการตอบกลับ สามารถทำอย่างอื่นได้หรือไม่? ฉันกำลังเรียกผู้โทร/ผู้รับแทนเซิร์ฟเวอร์/ไคลเอ็นต์ เนื่องจากการโทรเหล่านี้เกิดขึ้นได้ทุกที่ จากการออกแบบ เมื่อเราสร้างคอมพิวเตอร์ครั้งแรก ทุกอย่างเป็นแบบซิงโครนัส สิ่งนี้สามารถมองได้ว่าเป็นคลื่นไซน์ที่ผู้โทรและเซิร์ฟเวอร์ซิงค์หรือเป็นจังหวะเดียวกัน อะซิงโครนัสหมายความว่าไม่ซิงค์กัน

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

ตัวอย่างของ OS Synchronous I/O:
1. โปรแกรมขอให้ CPU อ่านไฟล์จากดิสก์
2. เธรดหลักของโปรแกรมถูกนำออกจาก CPU
3. อ่านเสร็จสิ้น และโปรแกรมจะเริ่มดำเนินการอีกครั้ง

// A simple Js example
// Program starts
// Programs uses CPU to execute work.

SampleFunction();
// Program reads from the disk
// Program can't do anything until file loads
readfile("SyncExample.dat")

// Program resumes

พูดเฉพาะจากจุด NodeJs มันใช้ epoll ใน Linux และในกรณีของ windows จะใช้สแต็คที่เสร็จสมบูรณ์ อีกสิ่งหนึ่งที่ nodeJs ทำคือสปินเธรดใหม่ที่บล็อกในกรณีที่จำเป็นต้องดำเนินการบล็อก ตามค่าเริ่มต้น Nodejs มี 4 เธรดของผู้ปฏิบัติงานใน ไลบรารี libuvซึ่งใช้สำหรับการดำเนินการ I/O แต่สามารถกำหนดค่าได้

ตัวอย่างของ OS asynchronous call (NodeJS)
a) โปรแกรมหมุนเธรดรอง
b) เธรดรองอ่านจากดิสก์ เห็นได้ชัดว่า OS ลบออกจากโปรเซสเซอร์ปัจจุบัน
c) โปรแกรมหลักยังคงทำงานและดำเนินการอยู่
d) จบเธรดและเรียกเธรดหลัก

// A simple Javascript example
// Program starts
// Programs uses CPU to execute work.

SampleFunction();
// Program reads from the disk
// Program hapilly moves on to the samplefunction2
readfile("SyncExample.dat", onReadFinish(console.log))
//file is not probably read yet

SampleFunction2();
//onReadFinish function called
// executing it

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

การประมวลผลแบ็กเอนด์แบบอะซิงโครนัส

ในฐานะวิศวกรแบ็กเอนด์ คงไม่ยุติธรรมถ้าฉันไม่พูดถึงการทำแบ็กเอนด์แบบอะซิงโครนัส ในโค้ด/ที่เก็บจำนวนมาก ไคลเอ็นต์เป็นแบบอะซิงโครนัสเป็นหลัก แต่แบ็กเอนด์ยังคงรอ ดังนั้นเมื่อไคลเอ็นต์ร้องขอให้พุชข้อมูล สมมติว่าทำการเรียกฐานข้อมูล หลายครั้งไคลเอ็นต์ขอให้รอการตอบกลับจากแบ็กเอนด์ ซึ่งส่งคืนการตอบกลับสถานะ 200 หลังจากคอมมิต ทีนี้ ถ้าเราย้ายเลนส์ไปที่แบ็คเอนด์ ส่วนหน้าจะเป็นอะซิงโครนัส แต่แบ็คเอนด์ยังคงเป็นซิงโครนัส แล้วเราจะตอบกลับทันทีได้อย่างไร?
หนึ่งในวิธีแก้ไขคือการใช้โครงสร้างข้อมูลที่สวยงามนี้ ซึ่งมีชื่อว่าคิว หากลูกค้าส่งคำขอ เราจะไม่สัญญาว่าจะดำเนินการทันที แต่เราจะล้างคำขอนั้นลงในคิว เหตุผลนี้คือแบ็คเอนด์อาจดำเนินการตามคำขอก่อนหน้านี้ และไคลเอ็นต์จะไม่ถูกบล็อกอีกต่อไป เราสามารถส่งการตอบกลับได้ว่าเราได้จัดคิวคำขอแล้ว และนี่คือสัญญา/JobID สำหรับข้อมูลเพิ่มเติม คุณสามารถอ่านเกี่ยวกับคิวข้อความ
มีโซลูชันยอดนิยมนอกเหนือจากนี้ ขึ้นอยู่กับกรณีการใช้งาน

ตัวอย่างโลกแห่งความเป็นจริงของภาระงานแบบอะซิงโครนัส: ก) การกระทำแบบอะซิงโค ร
นัสใน Postgres ↗
b) I/O แบบอะซิงโครนัสใน Linux (io-uring)
c) Asynchronous I/O fsync (fs-cache): เมื่อใดก็ตามที่เราเขียนบางสิ่งไปยังไฟล์ใดๆ มันจะไม่เขียนโดยตรงไปยังดิสก์ แต่ไปยังแคชของระบบไฟล์ มีแคชในระบบปฏิบัติการและการเขียนลงในหน้า จากนั้นระบบปฏิบัติการจะล้างหน้าทั้งหมดในครั้งเดียว

เราสามารถสรุปสิ่งทั้งหมดได้ดังนี้
a) วิธีการเขียนโปรแกรมแบบซิงโครนัสดำเนินการงานตามลำดับ แต่ละงานจะดำเนินการหลังจากรอให้งานก่อนหน้าเสร็จสิ้น
b) เมื่องานถูกรันในรูปแบบการเขียนโปรแกรมแบบอะซิงโครนัส เราสามารถไปยังอีกงานหนึ่งได้โดยไม่ต้องรอให้งานก่อนหน้าเสร็จสิ้น

ขอบคุณที่อ่าน; ฉันหวังว่ามันจะเป็นประโยชน์ ในกรณีที่มีข้อ สงสัย
เพิ่มเติม โปรดติดต่อผ่านLinkedIn / Instagram