ความแตกต่างระหว่างการเขียนโปรแกรมแบบซิงโครนัสและแบบอะซิงโครนัสคืออะไร (ใน node.js)

ฉันอ่านnodebeginner แล้วฉันก็เจอโค้ดสองชิ้นต่อไปนี้

คนแรก:

    var result = database.query("SELECT * FROM hugetable");
    console.log("Hello World");

คนที่สอง:

    database.query("SELECT * FROM hugetable", function(rows) {
       var result = rows;
    });
    console.log("Hello World");

ฉันได้สิ่งที่ควรทำพวกเขาค้นหาฐานข้อมูลเพื่อดึงคำตอบของแบบสอบถาม console.log('Hello world')แล้วก็

คนแรกคือรหัสซิงโครนัสที่คาดคะเน และอันที่สองคือรหัสอะซิงโครนัส

ความแตกต่างระหว่างสองชิ้นนั้นค่อนข้างคลุมเครือสำหรับฉัน ผลผลิตจะเป็นอย่างไร

Googling ในการเขียนโปรแกรมแบบอะซิงโครนัสไม่ได้ช่วยฉันเช่นกัน

ความแตกต่างคือในตัวอย่างแรกโปรแกรมจะบล็อกในบรรทัดแรก บรรทัดถัดไป ( console.log) จะต้องรอ

ในตัวอย่างที่สองที่console.logจะดำเนินการในขณะที่แบบสอบถามจะถูกประมวลผล นั่นคือแบบสอบถามจะถูกประมวลผลในพื้นหลังในขณะที่โปรแกรมของคุณกำลังทำสิ่งอื่น ๆ และเมื่อข้อมูลแบบสอบถามพร้อมคุณจะทำทุกอย่างที่คุณต้องการ

โดยสังเขป: ตัวอย่างแรกจะปิดกั้นในขณะที่สองจะไม่

ผลลัพธ์ของสองตัวอย่างต่อไปนี้:

// Example 1 - Synchronous (blocks)
var result = database.query("SELECT * FROM hugetable");
console.log("Query finished");
console.log("Next line");


// Example 2 - Asynchronous (doesn't block) 
database.query("SELECT * FROM hugetable", function(result) {
    console.log("Query finished");
});
console.log("Next line");

อยากจะเป็น:

1. Query finished
Next line
2. Next line
Query finished

หมายเหตุ
ขณะที่โหนดเองเป็นเธรดเดี่ยวมีงานบางอย่างที่สามารถทำงานแบบขนานได้ ตัวอย่างเช่นการทำงานของระบบไฟล์เกิดขึ้นในกระบวนการอื่น

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

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับสิ่งนี้ได้ที่นี่: วิธีการทำงานของ IO แบบเธรดที่ไม่บล็อกเธรดเดียวใน Node.js

ความแตกต่างระหว่างสองแนวทางนี้มีดังนี้:

วิธีการซิงโครนัส: มันรอให้การดำเนินการแต่ละครั้งเสร็จสมบูรณ์หลังจากนั้นจะทำการดำเนินการครั้งต่อไปเท่านั้น สำหรับการสืบค้นของคุณ: console.log()คำสั่งจะไม่ถูกดำเนินการจนกว่า & ถ้าแบบสอบถามไม่ได้ดำเนินการเสร็จสิ้นเพื่อรับผลลัพธ์ทั้งหมดจากฐานข้อมูล

วิธีแบบอะซิงโครนัส: มันไม่เคยรอให้การดำเนินการแต่ละครั้งเสร็จสมบูรณ์ แต่จะเรียกใช้การดำเนินการทั้งหมดใน GO แรกเท่านั้น ผลลัพธ์ของการดำเนินการแต่ละครั้งจะได้รับการจัดการเมื่อผลลัพธ์พร้อมใช้งาน สำหรับการค้นหาของคุณ: console.log()คำสั่งจะถูกดำเนินการในไม่ช้าหลังจากDatabase.Query()วิธีการ ในขณะที่แบบสอบถามฐานข้อมูลทำงานในพื้นหลังและโหลดผลลัพธ์เมื่อเสร็จสิ้นการดึงข้อมูล

ใช้กรณี

1. หากการดำเนินการของคุณไม่ยกอย่างหนักเช่นการสืบค้นข้อมูลขนาดใหญ่จากฐานข้อมูลให้ดำเนินการต่อด้วยวิธีการซิงโครนัสหรือวิธีอะซิงโครนัส

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

สิ่งนี้จะชัดเจนขึ้นอีกเล็กน้อยถ้าคุณเพิ่มบรรทัดลงในทั้งสองตัวอย่าง:

var result = database.query("SELECT * FROM hugetable");
console.log(result.length);
console.log("Hello World");

คนที่สอง:

database.query("SELECT * FROM hugetable", function(rows) {
   var result = rows;
   console.log(result.length);
});
console.log("Hello World");

ลองใช้สิ่งเหล่านี้แล้วคุณจะสังเกตเห็นว่าตัวอย่างแรก (ซิงโครนัส) ผลลัพธ์จะมีการพิมพ์ความยาวก่อนที่จะถึงบรรทัด 'Hello World' ในตัวอย่างที่สอง (แบบอะซิงโครนัส) ผลลัพธ์ของความยาวจะพิมพ์ออกมาหลังจากบรรทัด "Hello World"

นั่นเป็นเพราะในตัวอย่างที่สองการdatabase.queryรันแบบอะซิงโครนัสในพื้นหลังและสคริปต์ยังคงดำเนินต่อไปด้วย "Hello World" console.log(result.length)จะถูกดำเนินการเฉพาะเมื่อการสืบค้นฐานข้อมูลได้เสร็จสิ้น

ก่อนอื่นฉันรู้ว่าฉันมาสายในการตอบคำถามนี้

ก่อนพูดคุยเรื่องซิงโครนัสและอะซิงโครนัสขอให้เราดูว่าโปรแกรมทำงานอย่างไร

ในกรณีแบบซิงโครนัสแต่ละคำสั่งเสร็จสมบูรณ์ก่อนที่จะเรียกใช้คำสั่งถัดไป ในกรณีนี้โปรแกรมจะได้รับการประเมินตามคำสั่ง

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

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

    console.log("Hello World"); 

แบบสอบถามฐานข้อมูลยังคงอยู่ในระหว่างดำเนินการ แต่การดำเนินการ console.log อยู่ที่ด้านหน้าของคิวและรับการประมวลผล นี่เป็นการดำเนินการแบบซิงโครนัสที่เกิดขึ้นทันทีในผลลัพธ์ "Hello World" บางครั้งในภายหลังการดำเนินการฐานข้อมูลจะดำเนินการเสร็จสิ้นจากนั้นการเรียกกลับที่ลงทะเบียนกับแบบสอบถามจะถูกเรียกใช้และประมวลผลการตั้งค่าผลลัพธ์ของตัวแปรเป็นแถว

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

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

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

ไลบรารีจำนวนมากเช่น node 'fs' ให้ทั้งสไตล์ซิงโครนัสและอะซิงโครนัสสำหรับการดำเนินการบางอย่าง ในกรณีที่การดำเนินการใช้เวลาไม่นานและไม่ได้ใช้งานมากเช่นในกรณีที่อ่านไฟล์กำหนดค่าการดำเนินการสไตล์ซิงโครนัสจะส่งผลให้โค้ดอ่านง่ายขึ้น

ในกรณีแบบซิงโครนัสคำสั่ง console.log จะไม่ถูกดำเนินการจนกว่าแบบสอบถาม SQL จะดำเนินการเสร็จสิ้น

ในกรณีแบบอะซิงโครนัสคำสั่ง console.log จะถูกดำเนินการโดยตรง ผลลัพธ์ของแบบสอบถามจะถูกเก็บไว้โดยฟังก์ชัน "เรียกกลับ" ในภายหลัง

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

ฟังก์ชั่นทำให้หนึ่งที่สองไม่ตรงกัน

โปรแกรมแรกบังคับให้โปรแกรมรอให้แต่ละบรรทัดทำงานจนเสร็จก่อนที่โปรแกรมถัดไปจะทำงานต่อได้ บรรทัดที่สองอนุญาตให้แต่ละบรรทัดทำงานร่วมกัน (และเป็นอิสระ) ในครั้งเดียว

ภาษาและกรอบงาน (js, node.js) ที่อนุญาตแบบอะซิงโครนัสหรือการทำงานพร้อมกันนั้นยอดเยี่ยมสำหรับสิ่งที่ต้องการการส่งแบบเรียลไทม์ (เช่นการแชทแอปพลิเคชันสต็อค)

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

ภาษาการเขียนโปรแกรมเช่น C, C #, Java เป็นการเขียนโปรแกรมซิงค์สิ่งที่คุณเขียนจะถูกดำเนินการตามลำดับการเขียนของคุณ

-GET DATA FROM SQL.
//Suppose fetching data take 500 msec

-PERFORM SOME OTHER FUNCTION.
//Performing some function other will take 100 msec, but execution of other 
//task start only when fetching of sql data done (i.e some other function 
//can execute only after first in process job finishes).

-TOTAL TIME OF EXECUTION IS ALWAYS GREATER THAN (500 + 100 + processing time) 
msec

async

NodeJs มาพร้อมกับคุณสมบัติ async มันไม่ได้ปิดกั้นในลักษณะสมมติว่าในงาน I / O ใด ๆ ที่ต้องใช้เวลา (ดึง, เขียน, อ่าน), nodejs จะไม่ได้ใช้งานและรอให้งานเสร็จสิ้น ' จะเริ่มดำเนินการงานต่อไปในคิวและเมื่อใดก็ตามที่การรับงานเสร็จสมบูรณ์จะแจ้งให้ทราบโดยใช้การโทรกลับ ตัวอย่างต่อไปนี้จะช่วย:

//Nodejs uses callback pattern to describe functions.
//Please read callback pattern to understand this example

//Suppose following function (I/O involved) took 500 msec
function timeConsumingFunction(params, callback){
  //GET DATA FROM SQL
  getDataFromSql(params, function(error, results){
    if(error){
      callback(error);
    }
    else{
      callback(null, results);
    }
  })
}

//Suppose following function is non-blocking and took 100 msec
function someOtherTask(){
  //some other task
  console.log('Some Task 1');
  console.log('Some Task 2');
}

console.log('Execution Start');

//Start With this function
timeConsumingFunction(params, function(error, results){
    if(error){
      console.log('Error')
    }
    else{
      console.log('Successfull'); 
    }
  })

//As (suppose) timeConsumingFunction took 500 msec, 
//As NodeJs is non-blocking, rather than remain idle for 500 msec, it will start 
//execute following function immediately
someOtherTask();

ในระยะสั้นเอาท์พุทเป็นดังนี้:

Execution Start
//Roughly after 105 msec (5 msec it'll take in processing)
Some Task 1
Some Task 2
//Roughly After 510 msec
Error/Successful //depends on success and failure of DB function execution

ความแตกต่างนั้นชัดเจนว่าการซิงค์จะใช้เวลามากกว่า 600 (500 + 100 + เวลาประมวลผล) msec แน่นอน async ช่วยประหยัดเวลา

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

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

Orginal โพสต์บน Github: ลิงก์

การเขียนโปรแกรมแบบอะซิงโครนัสใน JS:

พร้อมกัน

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

ไม่ตรงกัน

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

ตัวอย่าง:

// This function is synchronous
function log(arg) {
    console.log(arg)
}

log(1);

// This function is asynchronous
setTimeout(() => {
    console.log(2)
}, 0);

log(3)

• ตัวอย่างบันทึก 1, 3, 2
• 2 ถูกบันทึกครั้งสุดท้ายเพราะมันอยู่ในฟังก์ชั่นแบบอะซิงโครนัสซึ่งจะถูกดำเนินการหลังจากที่สแต็กว่างเปล่า