ความแตกต่างระหว่างการเขียนโปรแกรมพร้อมกันและการเขียนโปรแกรมแบบขนานคืออะไร?

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

ตอนนี้ฉันพบคำอธิบายนี้แล้ว: http://www.linux-mag.com/id/7411 - แต่ "ภาวะพร้อมกันเป็นคุณสมบัติของโปรแกรม" vs "การทำงานแบบขนานเป็นคุณสมบัติของเครื่อง" ไม่เพียงพอสำหรับฉัน - ถึงกระนั้นฉันก็พูดอะไรไม่ออกไม่ได้

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

นี่คือตัวอย่างภาพ เธรดบนเครื่องที่ไม่ใช่เธรด :

        --  --  --
     /              \
>---- --  --  --  -- ---->>

เธรดบนเครื่องที่มีเธรด :

     ------
    /      \
>-------------->>

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

การเขียนโปรแกรมพร้อมกันเกี่ยวกับการดำเนินการที่ดูเหมือนจะทับซ้อนและเกี่ยวข้องกับความซับซ้อนเป็นหลักเนื่องจากการควบคุมการไหลที่ไม่ได้กำหนดไว้ล่วงหน้า ค่าใช้จ่ายเชิงปริมาณที่เกี่ยวข้องกับโปรแกรมที่เกิดขึ้นพร้อมกันมักจะมีทั้งปริมาณงานและเวลาแฝง โปรแกรมที่เกิดขึ้นพร้อมกันมักจะถูกผูกไว้กับ IO แต่ไม่เสมอไปเช่นตัวรวบรวมขยะที่เกิดขึ้นพร้อมกันนั้นเป็นแบบ on-CPU ตัวอย่างการสอนของโปรแกรมที่ทำงานพร้อมกันคือโปรแกรมรวบรวมข้อมูลเว็บ โปรแกรมนี้เริ่มต้นการร้องขอสำหรับหน้าเว็บและยอมรับคำตอบพร้อมกันเมื่อผลลัพธ์ของการดาวน์โหลดพร้อมใช้งานโดยรวบรวมชุดของหน้าเว็บที่เคยเข้าชมแล้ว โฟลว์การควบคุมนั้นไม่สามารถกำหนดได้เนื่องจากการตอบสนองนั้นไม่จำเป็นต้องได้รับในลำดับเดียวกันทุกครั้งที่มีการรันโปรแกรม คุณลักษณะนี้สามารถทำให้ยากมากในการดีบักโปรแกรมที่เกิดขึ้นพร้อมกันErlang , F # เวิร์กโฟลว์แบบอะซิงโครนัสและไลบรารีAkkaของ Scala อาจเป็นวิธีที่มีแนวโน้มมากที่สุดในการเขียนโปรแกรมพร้อมกันสูง

การเขียนโปรแกรมมัลติคอร์เป็นกรณีพิเศษของการเขียนโปรแกรมแบบขนาน การเขียนโปรแกรมแบบขนานเกี่ยวข้องกับการดำเนินการที่ซ้อนทับกันสำหรับเป้าหมายเฉพาะของการปรับปรุงทรูพุต ความยากลำบากในการเขียนโปรแกรมพร้อมกันจะหลีกเลี่ยงได้โดยการควบคุมการไหลของการกำหนด โดยทั่วไปโปรแกรมจะวางชุดของภารกิจลูกที่ทำงานในแบบคู่ขนานและภารกิจหลักจะดำเนินต่อเมื่อทุกภารกิจย่อยเสร็จสิ้นแล้ว สิ่งนี้ทำให้โปรแกรมคู่ขนานสามารถดีบักได้ง่ายกว่าโปรแกรมที่เกิดขึ้นพร้อมกัน ส่วนที่ยากของการเขียนโปรแกรมแบบขนานคือการเพิ่มประสิทธิภาพการปฏิบัติงานด้วยความเคารพในประเด็นต่าง ๆ เช่นความละเอียดและการสื่อสาร หลังยังคงเป็นปัญหาในบริบทของมัลติคอร์เนื่องจากมีค่าใช้จ่ายจำนวนมากที่เกี่ยวข้องกับการถ่ายโอนข้อมูลจากแคชหนึ่งไปยังอีกCilkอาจเป็นวิธีที่มีแนวโน้มมากที่สุดสำหรับการเขียนโปรแกรมแบบขนานที่มีประสิทธิภาพสูงในมัลติคอร์และได้รับการปรับใช้ทั้งในหน่วยการสร้างเธรดของ Intel และTask Parallel Libraryของ Microsoft (ใน. NET 4)

https://joearms.github.io/published/2013-04-05-concurrent-and-parallel-programming.html

เกิดขึ้นพร้อมกัน = สองคิวและเครื่องชงกาแฟหนึ่งเครื่อง

Parallel = สองคิวและเครื่องชงกาแฟสองเครื่อง

การตีความคำถามเดิมขนาน / พร้อมกันคำนวณแทนการเขียนโปรแกรม

ในการคำนวณพร้อมกันสองการคำนวณทั้งล่วงหน้าเป็นอิสระจากกัน การคำนวณครั้งที่สองไม่จำเป็นต้องรอจนกว่าการประมวลผลแรกจะเสร็จสิ้น อย่างไรก็ตามมันไม่ได้ระบุกลไกที่ทำให้เกิดสิ่งนี้ ในการตั้งค่าแบบ Single-Core จำเป็นต้องมีการระงับและการสลับระหว่างเธรด (หรือเรียกอีกอย่างว่ามัลติเธรดแบบpre-emptive )

ในการคำนวณแบบขนานการคำนวณสองแบบล่วงหน้าทั้งสองอย่างพร้อมกัน - นั่นคือตัวอักษรในเวลาเดียวกัน สิ่งนี้ไม่สามารถทำได้กับ CPU เดี่ยวและต้องการการตั้งค่าแบบมัลติคอร์แทน

ภาพจากบทความ: "Parallel vs Concurrent in Node.js"

กับ

ในมุมมองจากโปรเซสเซอร์มันสามารถอธิบายได้ด้วยรูปนี้

ในมุมมองจากโปรเซสเซอร์มันสามารถอธิบายได้ด้วยรูปนี้

ฉันเชื่อว่าการเขียนโปรแกรมพร้อมกันหมายถึงการเขียนโปรแกรมแบบมัลติเธรดซึ่งเป็นการอนุญาตให้โปรแกรมของคุณรันหลายเธรดโดยแยกออกจากรายละเอียดฮาร์ดแวร์

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

ฉันพบเนื้อหานี้ในบล็อกบางบล็อก คิดว่ามันมีประโยชน์และเกี่ยวข้อง

การเกิดขึ้นพร้อมกันและการขนานไม่ใช่สิ่งเดียวกัน งานสองรายการ T1 และ T2 จะเกิดขึ้นพร้อมกันถ้าลำดับที่งานสองงานถูกดำเนินการในเวลาไม่ได้กำหนดไว้ล่วงหน้า

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

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

ที่มา: https://blogs.oracle.com/yuanlin/entry/concurrency_vs_parallelism_concurrent_programming

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

ปัญหาที่นี่คือคนพยายามใช้สองวลีเพื่อแยกความแตกต่างที่ชัดเจนเมื่อไม่มีจริง ๆ ความจริงก็คือเส้นแบ่งที่พวกเขาพยายามวาดนั้นคลุมเครือและคลุมเครือมานานหลายสิบปีและมีความชัดเจนมากขึ้นเรื่อย ๆ เมื่อเวลาผ่านไป

สิ่งที่พวกเขากำลังพยายามที่จะหารือคือข้อเท็จจริงที่ว่ากาลครั้งหนึ่งคอมพิวเตอร์ส่วนใหญ่มี CPU เพียงตัวเดียว เมื่อคุณดำเนินการหลายกระบวนการ (หรือเธรด) บน CPU เดี่ยวนั้น CPU จะดำเนินการคำสั่งเดียวจากเธรดเหล่านั้นทีละตัวเท่านั้น การปรากฏตัวของการเกิดพร้อมกันนั้นเป็นภาพลวงตา - การสลับ CPU ระหว่างการดำเนินการคำสั่งจากเธรดที่แตกต่างกันอย่างรวดเร็วพอที่จะทำให้มนุษย์รับรู้ (ซึ่งมีอะไรน้อยกว่า 100 มิลลิวินาทีหรือทันทีทันใด)

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

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

ดังนั้นก่อนซีพียูแบบมัลติคอร์จะกลายเป็นบรรทัดฐานเรามีการดำเนินการจากหลายเธรดที่เกิดขึ้นพร้อมกัน

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

แต่ (เหมือนโฆษณาเคยพูด) รอ - นั่นไม่ใช่ทั้งหมด ยังมีองค์ประกอบการออกแบบอื่นเพื่อเพิ่มความสับสนต่อไป ได้รับชื่อค่อนข้างน้อย (เช่น "Hyperthreading", "SMT", "CMP") แต่พวกเขาทั้งหมดอ้างถึงแนวคิดพื้นฐานเดียวกัน: CPU ที่สามารถรันหลายเธรดพร้อมกันโดยใช้การรวมกันของทรัพยากรบางอย่างที่ ไม่ขึ้นอยู่กับแต่ละเธรดและทรัพยากรบางอย่างที่แบ่งใช้ระหว่างเธรด ในกรณีทั่วไปนี้จะรวมกับความเท่าเทียมในระดับคำสั่งที่อธิบายไว้ข้างต้น ในการทำเช่นนั้นเรามีชุดรีจิสเตอร์สถาปัตยกรรมสองชุดขึ้นไป จากนั้นเรามีชุดของหน่วยดำเนินการที่สามารถดำเนินการคำสั่งได้ทันทีที่ทรัพยากรที่จำเป็นมีอยู่

แน่นอนว่าเราไปถึงระบบที่ทันสมัยที่มีหลายคอร์ นี่คือสิ่งที่ชัดเจนใช่มั้ย เรามี N (บางที่ระหว่าง 2 ถึง 256 หรือมากกว่านั้นในขณะนี้) แกนที่แยกต่างหากซึ่งสามารถดำเนินการคำสั่งได้ในเวลาเดียวกันดังนั้นเราจึงมีกรณีที่ชัดเจนของการขนานขนานจริง - ดำเนินการคำสั่งในกระบวนการเดียว / เธรด ' ไม่ส่งผลกระทบต่อคำสั่งในการดำเนินการในอีก

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

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

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

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

ผู้คนพยายามวาดความแตกต่างที่ชัดเจนระหว่าง "ขนาน" และ "พร้อมกัน" กำลังใช้ชีวิตอยู่ในจินตนาการของคอมพิวเตอร์ที่ไม่เคยมีอยู่จริง

• Concurrent programmingโดยทั่วไปแล้วหมายถึงสภาพแวดล้อมที่งานที่เรากำหนดสามารถเกิดขึ้นได้ในลำดับใด ๆ งานหนึ่งสามารถเกิดขึ้นก่อนหรือหลังงานอื่นและงานบางส่วนหรือทั้งหมดสามารถทำได้ในเวลาเดียวกัน

• Parallel programmingเป็นการอ้างถึงการเรียกใช้งานพร้อมกันของตัวประมวลผลที่แตกต่างกันพร้อมกันโดยเฉพาะ ดังนั้นการเขียนโปรแกรมแบบขนานทั้งหมดจะเกิดขึ้นพร้อมกัน แต่การเขียนโปรแกรมแบบขนานทั้งหมดไม่ได้เป็นแบบขนาน

ที่มา: การโปรแกรม PThreads - มาตรฐาน POSIX สำหรับการประมวลผลหลายขั้นตอนที่ดีขึ้น, Buttlar, Farrell, Nichols

ในการเขียนโปรแกรมการทำงานพร้อมกันคือองค์ประกอบของกระบวนการดำเนินการอย่างอิสระในขณะที่การขนานคือการคำนวณ (อาจเกี่ยวข้อง) พร้อมกัน
- Andrew Gerrand -

และ

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

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

เพื่อให้เข้าใจถึงความแตกต่างฉันขอแนะนำให้ดูวิดีโอของ Rob Pike (หนึ่งในผู้สร้าง Golang) นี้ การเกิดขึ้นพร้อมกันนั้นไม่ขนานกัน

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

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

การจัดตารางคลาสสิกของงานที่สามารถ อนุกรม , ขนานหรือพร้อมกัน

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

• Parallel : งานที่ต้องดำเนินการในเวลาเดียวกันไม่เช่นนั้นจะไม่ทำงาน

  • ความล้มเหลวใด ๆ ของงานใด ๆ - การทำงานหรือในเวลา - จะส่งผลให้ความล้มเหลวของระบบทั้งหมด
  • งานทั้งหมดจะต้องมีเวลาที่เชื่อถือได้ทั่วไป
    
    

  พยายามหลีกเลี่ยงสิ่งนี้หรือเราจะมีน้ำตาตามเวลาน้ำชา

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

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

ผู้คนมักคิดว่านี่เป็นเรื่องเกี่ยวกับซอฟต์แวร์ แต่ในความเป็นจริงแล้วแนวคิดการออกแบบระบบที่จัดเตรียมคอมพิวเตอร์ไว้ล่วงหน้า ระบบซอฟต์แวร์มีความล่าช้าเล็กน้อยในการดูดซึมภาษาซอฟต์แวร์น้อยมากแม้แต่พยายามแก้ไขปัญหา คุณอาจลองมองขึ้นไปภาษา Transputer Occamหากคุณสนใจ

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

• กริยา - สิ่งที่คุณกำลังทำ (การทำงานหรืออัลกอริทึม)
• คำนาม - สิ่งที่คุณทำ (ข้อมูลหรือส่วนต่อประสาน)
• เมื่อ - การเริ่มต้นกำหนดเวลาการเปลี่ยนแปลงสถานะ
• อย่างไร - อนุกรม, ขนาน, พร้อมกัน
• ที่ไหน - เมื่อคุณรู้ว่าเมื่อสิ่งต่าง ๆ เกิดขึ้นคุณสามารถพูดได้ว่าสิ่งที่พวกเขาสามารถเกิดขึ้นได้และไม่ก่อน
• ทำไม - นี่เป็นวิธีที่จะทำหรือไม่ มีวิธีอื่นและที่สำคัญกว่านั้นคือวิธีที่ดีกว่า จะเกิดอะไรขึ้นถ้าคุณไม่ทำ

โชคดี.

ฉันเข้าใจความแตกต่างที่เป็น:

1) Concurrent - ทำงานควบคู่โดยใช้ทรัพยากรที่ใช้ร่วมกัน 2) Parallel - Running เคียงข้างกันโดยใช้ทรัพยากรที่แตกต่างกัน

ดังนั้นคุณสามารถมีสองสิ่งที่เกิดขึ้นในเวลาเดียวกันเป็นอิสระจากกันแม้ว่าพวกเขาจะมารวมกันที่จุด (2) หรือสองสิ่งที่วาดบนทุนสำรองเดียวกันตลอดการดำเนินการ (1)

แม้ว่าจะไม่มีข้อตกลงที่สมบูรณ์เกี่ยวกับความแตกต่างระหว่างคำขนานและเกิดขึ้นพร้อมกันผู้เขียนหลายคนสร้างความแตกต่างดังต่อไปนี้:

• ในการคำนวณพร้อมกันโปรแกรมคือสิ่งที่หลาย ๆ งานสามารถดำเนินการได้ทันที
• ในการคำนวณแบบขนานโปรแกรมคือสิ่งที่หลาย ๆ งานร่วมมือกันอย่างใกล้ชิดเพื่อแก้ปัญหา

ดังนั้นโปรแกรมแบบขนานจึงเกิดขึ้นพร้อมกัน แต่โปรแกรมเช่นระบบปฏิบัติการมัลติทาสกิ้งก็จะเกิดขึ้นพร้อมกันแม้ในขณะที่มันรันบนเครื่องที่มีแกนเดียวเพียงแกนเดียว

ที่มา : บทนำเกี่ยวกับการเขียนโปรแกรมแบบขนานPeter Pacheco

แหล่งที่มาพร้อมกันและขนาน

ในกระบวนการแบบมัลติเธรดบนหน่วยประมวลผลเดียวโปรเซสเซอร์สามารถสลับทรัพยากรการดำเนินการระหว่างหัวข้อผลในการดำเนินการพร้อมกัน

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

เมื่อกระบวนการมีจำนวนเธรดที่น้อยกว่าหรือมากเท่าที่มีตัวประมวลผลระบบจะรองรับเธรดร่วมกับสภาพแวดล้อมการทำงานเพื่อให้แน่ใจว่าแต่ละเธรดทำงานบนโปรเซสเซอร์ที่แตกต่างกัน

ตัวอย่างเช่นในการคูณเมทริกซ์ที่มีจำนวนเธรดและตัวประมวลผลเท่ากันแต่ละเธรด (และตัวประมวลผลแต่ละตัว) จะคำนวณแถวของผลลัพธ์

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

นามธรรมพื้นฐานที่จะทำในวิทยาการคอมพิวเตอร์ที่ทั้งสองเห็นพ้องและขนานจะมีการบันทึกคุณสมบัติของโปรแกรม ที่นี่โปรแกรมมีคำอธิบายอย่างเป็นทางการของการคำนวณ โปรแกรมดังกล่าวไม่จำเป็นต้องอยู่ในภาษาเฉพาะหรือการเข้ารหัสใด ๆ ซึ่งเป็นการใช้งานเฉพาะ การมีอยู่ของ API / ABI / ISA / OS นั้นไม่เกี่ยวข้องกับระดับของนามธรรม แน่นอนว่าจะต้องมีความรู้เฉพาะการใช้งานอย่างละเอียดมากขึ้น (เช่นแบบจำลองเกลียว) เพื่อทำงานเขียนโปรแกรมที่เป็นรูปธรรมจิตวิญญาณที่อยู่เบื้องหลังสิ่งที่เป็นนามธรรมไม่เปลี่ยนแปลง

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

สำหรับความแตกต่างทั่วไปดูคำตอบที่เกี่ยวข้องสำหรับมุมมองพื้นฐานของการเกิดพร้อมกันโวลต์ขนาน (นอกจากนี้ยังมีลิงก์บางลิงค์ที่มีแหล่งข้อมูลเพิ่มเติม)

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

ภาษาการเขียนโปรแกรมอาจเปิดเผยคุณสมบัติที่ตั้งใจไว้โดยกฎความหมายในตัว ในกรณีส่วนใหญ่กฎดังกล่าวระบุการประเมินของโครงสร้างภาษาเฉพาะ (เช่นการแสดงออก) ทำให้การคำนวณมีส่วนร่วมอย่างมีประสิทธิภาพพร้อมกันหรือขนาน (โดยเฉพาะอย่างยิ่งผลการคำนวณที่แสดงถึงการประเมินสามารถสะท้อนคุณสมบัติเหล่านี้ได้อย่างสมบูรณ์แบบ) อย่างไรก็ตามความหมายของภาษาพร้อมกัน / ขนานนั้นมีความซับซ้อนเป็นหลักและไม่จำเป็นต้องใช้ในการปฏิบัติงานจริง ) ดังนั้นภาษาดั้งเดิมส่วนใหญ่จะใช้วิธีการอนุรักษ์มากขึ้นและง่าย: สมมติว่าความหมายของการประเมินผลโดยสิ้นเชิงลำดับและอนุกรมแล้วให้พื้นฐานจำเป็นที่จะช่วยให้บางส่วนการคำนวณพร้อมกันและขนาน ดั้งเดิมเหล่านี้สามารถเป็นคำหลักหรือโครงสร้างขั้นตอน ("ฟังก์ชั่น") ได้รับการสนับสนุนโดยภาษา พวกเขาจะดำเนินการตามการโต้ตอบกับสภาพแวดล้อมโฮสต์ (OS หรืออินเตอร์เฟซฮาร์ดแวร์ "โลหะเปลือย") มักจะทึบ (ไม่สามารถที่จะได้รับโดยใช้ภาษาแบบพกพา) กับภาษา ดังนั้นใน abstractions ระดับสูงที่เห็นโดยโปรแกรมเมอร์ชนิดนี้ไม่มีอะไรเกิดขึ้นพร้อมกัน / ขนานกันนอกเหนือจากดั้งเดิม "magic" และโปรแกรมที่ใช้อาศัย primitives เหล่านี้ โปรแกรมเมอร์สามารถเพลิดเพลินกับประสบการณ์การเขียนโปรแกรมที่ผิดพลาดน้อยลงเมื่อคุณสมบัติการทำงานพร้อมกัน / การขนานไม่ได้รับความสนใจ

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

ภายใต้ระดับของเธรดเฉพาะภาษามีการทำงานหลายอย่างในสภาพแวดล้อมการโฮสต์พื้นฐาน (โดยทั่วไปคือระบบปฏิบัติการ) มัลติทาสกิ้งที่ยึดเอาไว้ในระดับ OS ใช้เพื่อทำมัลติเธรด (ยึดเอาเสีย) ในบางสภาพแวดล้อมเช่น Windows NT หน่วยการจัดตารางพื้นฐาน (งาน) ก็เป็น "เธรด" ด้วยเช่นกัน เพื่อแยกแยะความแตกต่างกับการใช้งานพื้นที่ผู้ใช้ของเธรดที่กล่าวถึงข้างต้นพวกเขาถูกเรียกว่าเคอร์เนลเธรดโดยที่ "เคอร์เนล" หมายถึงเคอร์เนลของระบบปฏิบัติการ_{(อย่างไรก็ตามการพูดอย่างเคร่งครัด} ผู้บริหารระดับสูง) เธรดเคอร์เนลจะไม่แมปกับ 1: 1 เสมอกับ userspace แม้ว่าการแมป 1: 1 มักจะลดค่าใช้จ่ายในการทำแผนที่ส่วนใหญ่ เนื่องจากเคอร์เนลเธรดมีน้ำหนักมาก (เกี่ยวข้องกับการเรียกใช้ระบบ) เพื่อสร้าง / ทำลาย / สื่อสารเธรดสีเขียวในพื้นที่ผู้ใช้เพื่อเอาชนะปัญหาค่าใช้จ่ายในค่าใช้จ่ายของการทำแผนที่ค่าใช้จ่าย ทางเลือกของการทำแผนที่ขึ้นอยู่กับกระบวนทัศน์การเขียนโปรแกรมที่คาดหวังในสิ่งที่เป็นนามธรรมระดับสูง ตัวอย่างเช่นเมื่อเธรดสเปซผู้ใช้จำนวนมากคาดว่าจะถูกเรียกใช้งานพร้อมกัน (เช่นErlang ) การแมป 1: 1 จะไม่สามารถทำได้

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

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

เพียงแบ่งปันตัวอย่างที่ช่วยเน้นความแตกต่าง:

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

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

ดังที่คนอื่น ๆ กล่าวถึงโปรแกรมขนานทุกโปรแกรมพร้อมกัน (ต้องเป็นจริง) แต่ไม่ใช่วิธีอื่น ๆ

ฉันจะพยายามอธิบายในสไตล์ของฉันเองมันอาจไม่ได้อยู่ในแง่ของคอมพิวเตอร์ แต่มันให้ความคิดทั่วไปกับคุณ

ลองมาดูตัวอย่างพูดเหลือเกินครัวเรือน: ทำความสะอาดจานนำขยะออกไปตัดหญ้า ฯลฯ และเรามี 3 คน (กระทู้) A, B, C เพื่อทำมัน

พร้อมกัน: บุคคลทั้งสามเริ่มงานที่แตกต่างกันอย่างอิสระเช่น

A --> cleaning dishes
B --> taking out trash 
C --> mowing the lawn 

ที่นี่ลำดับของงานไม่แน่นอนและการตอบสนองขึ้นอยู่กับปริมาณของงาน

Parallel: ที่ นี่ถ้าเราต้องการปรับปรุง throughput เราสามารถมอบหมายคนหลายคนให้ทำงานเดี่ยวตัวอย่างเช่นการล้างจานที่เรากำหนดให้คนสองคน A การล้างจานและ B การล้างจานซึ่งอาจทำให้ throughput ดีขึ้น

ทำความสะอาดจาน:

A --> soaping the dishes
B --> washing the dishes

เป็นต้น

หวังว่านี่จะให้ความคิด! ตอนนี้ไปยังข้อกำหนดทางเทคนิคซึ่งอธิบายไว้ในคำตอบอื่น ๆ ;)