ที่นี่ฉันอธิบายด้วยตัวอย่าง
ความเท่าเทียม
GPUใช้การประมวลผลแบบขนานที่จะดำเนินการบล็อกเดียวกันของรหัส (AKA เคอร์เนล ) ในพันของหัวข้อทางกายภาพและตรรกะ เป็นการดีที่กระบวนการเริ่มต้นและสิ้นสุดสำหรับเธรดทั้งหมดในเวลาเดียวกัน CPU แกนเดียวที่ไม่มีไฮเปอร์เธรดไม่สามารถทำการประมวลผลแบบขนานได้
หมายเหตุ:ฉันพูดอย่างยอดเยี่ยมเพราะเมื่อคุณรันเคอร์เนลที่มีขนาดการโทร 7M บนฮาร์ดแวร์ที่มีเธรด 6M จะต้องรันสองครั้งที่รันโค้ดเดียวกันบนเธรด 6M ทั้งหมดแบบขนานในขณะที่ใช้เธรด 6M ทั้งหมดในแต่ละครั้ง
- หนึ่งเคอร์เนล (ชิ้นส่วนของรหัส) ถูกดำเนินการกับโปรเซสเซอร์หลายตัว
- พร้อมกัน
- ด้วยลำดับการเรียกใช้งานครั้งเดียว ( เคอร์เนลต้องทำสิ่งเดียวกันในทุกเธรดดังนั้น "branching" หรือ "ถ้า" s หลีกเลี่ยงเพราะจะใช้ทรัพยากรอย่างมากโดยการสร้าง NOP จำนวนมาก (ไม่มีการดำเนินการ) เพื่อซิงโครไนซ์เธรดทั้งหมด)
- เป็นหลักเพิ่มความเร็วอย่างมาก
- จำกัดอย่างมากในสิ่งที่คุณสามารถทำได้
- ขึ้นอยู่กับฮาร์ดแวร์
หมายเหตุ: Parallelism ไม่ จำกัด เฉพาะ GPU
เห็นพ้องด้วย
บริการเว็บได้รับการร้องขอขนาดเล็กจำนวนมากในเวลาจริงและจะต้องจัดการกับแต่ละคำขอเหล่านี้แตกต่างกันในเวลาใด ๆ และเป็นอิสระจากความต้องการอื่น ๆ หรืองานใด ๆ ภายใน แต่คุณต้องการให้บริการบนเว็บพร้อมทำงานตลอดเวลาโดยไม่ทำลายสถานะของข้อมูลหรือความสมบูรณ์ของระบบ
แค่คิดว่าผู้ใช้อัปเดตบันทึกและผู้ใช้รายอื่นลบบันทึกเดียวกันในเวลาเดียวกัน
- งานจำนวนมากถูกประหารชีวิต
- ตามเวลาจริง (หรือเมื่อใดก็ตามที่มีคำขอ)
- ด้วยลำดับการดำเนินการที่แตกต่างกัน (ซึ่งแตกต่างจากเคอร์เนลในการประมวลผลแบบขนานงานที่เกิดขึ้นพร้อมกันสามารถทำสิ่งที่แตกต่างกันคุณมักจะต้องจัดคิวหรือจัดลำดับความสำคัญ)
- ปรับปรุงเวลาตอบสนองเฉลี่ยเป็นหลักเนื่องจากภารกิจ # 2 ไม่จำเป็นต้องรอให้งาน # 1 เสร็จสิ้น
- หลักเสียสละเวลาคำนวณเพราะงานจำนวนมากกำลังทำงานในเวลาเดียวกันและมีทรัพยากรที่ จำกัด
- จำเป็นต้องจัดการทรัพยากรที่ใช้ร่วมกันอย่างเหมาะสมดังนั้นจึงไม่ทำให้เกิดการหยุดชะงักหรือทำให้ข้อมูลเสียหาย
หมายเหตุ : การร้องขอเหล่านี้มักใช้ทรัพยากรที่จำเป็นบางอย่างเช่นหน่วยความจำการเชื่อมต่อฐานข้อมูลหรือแบนด์วิดท์ แต่คุณต้องการให้บริการเว็บตอบสนองได้ตลอดเวลา อะซิงโครนัสเป็นกุญแจสำคัญในการตอบสนองไม่ใช่การทำงานพร้อมกัน
ไม่ตรงกัน
กระบวนการหนักหนึ่งกระบวนการ (เช่นการดำเนินการ I / O) สามารถบล็อก GUIได้อย่างง่ายดายหากทำงานบนเธรด GUI เพื่อรับประกันการตอบสนองของ UIกระบวนการที่หนักสามารถดำเนินการแบบอะซิงโครนัส มันจะดีกว่าที่จะทำงานที่คล้ายกันดำเนินงาน async หนึ่งที่เวลา เช่นการดำเนินการ IO หลายขอบเขตอาจช้าลงอย่างมากหากทำงานพร้อมกันดังนั้นจึงเป็นการดีกว่าที่จะจัดคิวให้เสร็จ
- งานหนึ่งหรือชุดของงานจะดำเนินการในหัวข้ออื่น
- ครั้งหนึ่ง
- หากมีภารกิจเดียวก็ไม่มีลำดับดังนั้นคุณอาจรอให้เสร็จหรือไฟและลืม
- ถ้ามันเป็นชุดของงานคุณก็จะลืมและลืมไปพร้อม ๆ กันรอให้ทุกคนเสร็จสิ้นหรือเรียกใช้แต่ละงานให้เสร็จเพื่อเริ่ม
- ลดประสิทธิภาพเป็นหลักเนื่องจากค่าโสหุ้ย
- ให้การตอบสนองต่อเธรดอื่น (มีผลต่อการบล็อกเธรด UI หรือเธรดที่จำเป็นอื่น ๆ )
หมายเหตุ:การดำเนินการ async ซึ่งดำเนินการพร้อมกัน (เช่นมากกว่าหนึ่งครั้ง) เป็นการดำเนินการพร้อมกัน
หมายเหตุ: การเกิดพร้อมกันและไม่ตรงกันมักจะสับสนกัน การทำงานพร้อมกันหมายถึงส่วนต่าง ๆ ของระบบที่ทำงานร่วมกันโดยไม่รบกวนซึ่งกันและกัน (ปัญหาเหล่านี้มักจะถูกแก้ไขด้วยการล็อค, เซมาฟอร์หรือ mutexes) อะซิงโครนัสเป็นวิธีที่คุณบรรลุการตอบสนอง (เช่นเธรด)
* หมายเหตุ: Asynchronousy และ Multithreading มักจะสับสนซึ่งกันและกัน รหัสแบบอะซิงโครนัสไม่จำเป็นต้องเกี่ยวข้องกับเธรดใหม่ มันอาจเป็นการทำงานของฮาร์ดแวร์หรือตามที่สเตฟานเรียกมันว่าเป็นการดำเนินการที่แท้จริงอ่านนี่สิ
เช่นในรหัส WPF + C # ด้านล่างawait Task.Run(()=> HeavyMethod(txt))กำลังแก้ปัญหาแบบอะซิงโครนัสในขณะที่ textBox.Dispatcher.Invokeกำลังแก้ปัญหาที่เกิดขึ้นพร้อมกัน:
private async void ButtonClick(object sender, RoutedEventArgs e)
{
// run a method in another thread
await Task.Run(()=> HeavyMethod(txt));
// modify UI object in UI thread
txt.Text = "done";
}
// This is a thread-safe method. You can run it in any thread
internal void HeavyMethod(TextBox textBox)
{
while (stillWorking)
{
// use Dispatcher to safely invoke UI operations
textBox.Dispatcher.Invoke(() =>
{
// UI operations outside of invoke will cause ThreadException
textBox.Text += ".";
});
}
}
