การประมวลผลพร้อมกัน

แนวคิดของการประมวลผลพร้อมกันมักสับสนกับแนวคิดที่เกี่ยวข้องแต่แตกต่างกันของ^การประมวลผลแบบขนาน [ ^{3 ] [ 4 ]}แม้ว่าทั้งสองจะสามารถอธิบายได้ว่าเป็น "กระบวนการหลายกระบวนการที่ทำงานในช่วงเวลาเดียวกัน " ในการประมวลผลแบบขนาน การทำงานจะเกิดขึ้นในเวลาเดียวกันทางกายภาพ เช่น บนโปรเซสเซอร์ ที่แยกจากกัน ของ เครื่อง มัลติโปรเซสเซอร์โดยมีเป้าหมายเพื่อเร่งความเร็วในการคำนวณ การประมวลผลแบบขนานเป็นไปไม่ได้บนโปรเซสเซอร์เดี่ยว ( หนึ่งคอร์ ) เนื่องจากมีเพียงการคำนวณเดียวเท่านั้นที่สามารถเกิดขึ้นได้ในแต่ละช่วงเวลา (ในระหว่างรอบสัญญาณนาฬิกาเดียว) ^{[ a ]} ​​ในทางตรงกันข้าม การประมวลผลพร้อมกันประกอบด้วยอายุการ ใช้งานของกระบวนการ ที่ทับซ้อนกัน แต่การทำงานไม่ได้เกิดขึ้นในเวลาเดียวกัน เป้าหมายในที่นี้คือการจำลองกระบวนการที่เกิดขึ้นพร้อมกัน เช่น ลูกค้าหลายรายเข้าถึงเซิร์ฟเวอร์ในเวลาเดียวกัน การจัดโครงสร้างระบบซอฟต์แวร์ให้ประกอบด้วยส่วนต่างๆ ที่ทำงานพร้อมกันและสื่อสารกันนั้นมีประโยชน์สำหรับการจัดการกับความซับซ้อน โดยไม่คำนึงว่าส่วนต่างๆ จะสามารถทำงานแบบขนานได้หรือไม่^{[ 5 ] : 1}

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

การคำนวณพร้อมกันอาจดำเนินการแบบขนานได้^{[ 3 ] [ 6 ]}ตัวอย่างเช่น โดยการกำหนดแต่ละกระบวนการให้กับโปรเซสเซอร์หรือแกนประมวลผลแยกต่างหาก หรือกระจายการคำนวณผ่านเครือข่าย

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

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

คำว่า "ลำดับ" ถูกใช้เป็นคำตรงข้ามกับทั้ง "พร้อมกัน" และ "ขนาน" เมื่อมีการแยกแยะอย่างชัดเจน คำว่าพร้อมกัน/ลำดับและขนาน/อนุกรมจะถูกใช้เป็นคู่ตรงข้าม^{[ 7 ]}ตารางเวลาที่งานต่างๆ ดำเนินการทีละงาน (อนุกรม ไม่มีการทำงานแบบขนาน) โดยไม่มีการสลับงาน (ลำดับ ไม่มีการทำงานพร้อมกัน: ไม่มีงานใดเริ่มต้นจนกว่างานก่อนหน้าจะเสร็จสิ้น) เรียกว่า ตารางเวลาอนุกรมชุดของงานที่สามารถกำหนดตารางเวลาแบบอนุกรมได้เรียกว่าserializableซึ่งทำให้การควบคุมการทำงานพร้อมกันง่าย ขึ้น

ความท้าทายหลักในการออกแบบโปรแกรมพร้อมกันคือการควบคุมการทำงานพร้อมกัน : การรับรองลำดับที่ถูกต้องของการโต้ตอบหรือการสื่อสารระหว่างการดำเนินการคำนวณที่แตกต่างกัน และการประสานงานการเข้าถึงทรัพยากรที่ใช้ร่วมกันระหว่างการดำเนินการ^{[ 6 ]}ปัญหาที่อาจเกิดขึ้น ได้แก่สภาวะการแข่งขันการติดตายและการขาดแคลนทรัพยากรตัวอย่างเช่น พิจารณาอัลกอริทึมต่อไปนี้เพื่อถอนเงินจากบัญชีตรวจสอบที่แสดงโดยทรัพยากรที่ใช้ร่วมกันbalance:

bool ถอน( int การถอน){ถ้า( ยอดคงเหลือ>= ยอดถอน){ยอดคงเหลือ-= การถอนเงิน;ส่งคืนค่าจริง;}ส่งคืนค่าเท็จ;}

สมมติว่า มีเธรด balance = 500สองเธรด ที่ทำงานพร้อมกัน โดยเธรดแรก เรียกใช้ฟังก์ชัน `command` withdraw(300)และwithdraw(350)`command` ถ้าบรรทัดที่ 3 ในทั้งสองการทำงานเสร็จก่อนบรรทัดที่ 5 ทั้งสองการทำงานจะพบว่าbalance >= withdrawal`command` มีtrueค่าเป็น `false` และการทำงานจะดำเนินต่อไปโดยการหักจำนวนเงินที่ถอนออก อย่างไรก็ตาม เนื่องจากทั้งสองกระบวนการทำการถอนเงิน จำนวนเงินที่ถอนทั้งหมดจึงมากกว่ายอดเงินคงเหลือเดิม ปัญหาประเภทนี้ที่เกี่ยวข้องกับทรัพยากรที่ใช้ร่วมกันจะได้รับประโยชน์จากการควบคุมการทำงานพร้อมกัน หรือ อัลก อริ ทึมแบบไม่บล็อก

การประมวลผลแบบขนานมีข้อดีหลายประการ:

• ประสิทธิภาพการทำงานของโปรแกรมที่เพิ่มขึ้น—การดำเนินการแบบขนานของอัลกอริทึมพร้อมกันช่วยให้จำนวนงานที่เสร็จสมบูรณ์ในเวลาที่กำหนดเพิ่มขึ้นตามสัดส่วนของจำนวนโปรเซสเซอร์ตาม กฎ ของGustafson ^{[ 8 ]}
• การตอบสนองสูงสำหรับอินพุต/เอาต์พุต—โปรแกรมที่เน้นอินพุต/เอาต์พุตส่วนใหญ่จะรอให้การดำเนินการอินพุตหรือเอาต์พุตเสร็จสมบูรณ์ การเขียนโปรแกรมแบบขนานช่วยให้เวลาที่เสียไปกับการรอคอยสามารถนำไปใช้กับงานอื่นได้^{[ 9 ]}
• โครงสร้างโปรแกรมที่เหมาะสมกว่า—ปัญหาและขอบเขตปัญหาบางอย่างเหมาะสมที่จะแสดงในรูปแบบของงานหรือกระบวนการที่ทำงานพร้อมกัน ตัวอย่างเช่นMVCC

โครงข่ายเพทรี (Petri nets)ซึ่งเปิดตัวในปี 1962 เป็นความพยายามแรกๆ ในการกำหนดกฎเกณฑ์ของการประมวลผลพร้อมกัน ทฤษฎีการไหลของข้อมูล (Dataflow theory) พัฒนาต่อยอดจากโครงข่ายเพทรีในภายหลัง และสถาปัตยกรรมการไหลของข้อมูล (Dataflow architectures) ถูกสร้างขึ้นเพื่อนำแนวคิดของทฤษฎีการไหลของข้อมูลไปใช้ในทางปฏิบัติ ตั้งแต่ปลายทศวรรษ 1970 เป็นต้นมา มีการพัฒนา แคลคูลัสกระบวนการเช่นแคลคูลัสของระบบสื่อสาร (Calculus of Communicating Systems : CCS) และกระบวนการลำดับสื่อสาร (Communicating Sequential Processes : CSP) เพื่อให้สามารถใช้เหตุผลเชิงพีชคณิตเกี่ยวกับระบบที่ประกอบด้วยส่วนประกอบที่โต้ตอบกันได้แคลคูลัส πเพิ่มความสามารถในการใช้เหตุผลเกี่ยวกับโทโพโลยีแบบไดนามิก

ออโตมาตาแบบอินพุต/เอาต์พุตได้รับการแนะนำครั้งแรกในปี 1987

ตรรกะต่างๆ เช่นTLA+ ของ Lamport และแบบจำลองทางคณิตศาสตร์ เช่นtraceและActor event diagramได้รับการพัฒนาขึ้นเพื่ออธิบายพฤติกรรมของระบบแบบขนาน

หน่วยความจำธุรกรรมแบบซอฟต์แวร์ ยืม แนวคิดเรื่องธุรกรรมอะตอมิกจากทฤษฎีฐานข้อมูลและนำมาประยุกต์ใช้กับการเข้าถึงหน่วยความจำ

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

หนึ่งในแบบจำลองความสอดคล้องแรกๆ คือ แบบจำลอง ความสอดคล้องตามลำดับของLeslie Lamportความสอดคล้องตามลำดับคือคุณสมบัติของโปรแกรมที่การดำเนินการของโปรแกรมนั้นให้ผลลัพธ์เหมือนกับโปรแกรมตามลำดับ โดยเฉพาะอย่างยิ่ง โปรแกรมจะมีความสอดคล้องตามลำดับหาก "ผลลัพธ์ของการดำเนินการใดๆ เหมือนกับว่าการดำเนินการของโปรเซสเซอร์ทั้งหมดถูกดำเนินการตามลำดับ และการดำเนินการของโปรเซสเซอร์แต่ละตัวปรากฏในลำดับนี้ตามลำดับที่ระบุโดยโปรแกรม" ^{[ 10 ]}

สามารถใช้วิธีการต่างๆ มากมายในการเขียนโปรแกรมแบบขนาน เช่น การดำเนินการคำนวณแต่ละครั้งเป็นกระบวนการของระบบปฏิบัติการหรือการดำเนินการคำนวณเหล่านั้นเป็นชุดของเธรดภายในกระบวนการของระบบปฏิบัติการเดียว

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

การสื่อสารหน่วยความจำร่วม

ส่วนประกอบที่ทำงานพร้อมกันจะสื่อสารกันโดยการเปลี่ยนแปลงเนื้อหาของ ตำแหน่ง หน่วยความจำที่ใช้ร่วมกัน (ตัวอย่างเช่นJavaและC# ) การเขียนโปรแกรมแบบพร้อมกันในลักษณะนี้มักต้องการการใช้กลไกการล็อกบางรูปแบบ (เช่นมิวเท็กซ์เซมาฟอร์หรือมอนิเตอร์ ) เพื่อประสานงานระหว่างเธรด โปรแกรมที่ใช้งานกลไกเหล่านี้อย่างถูกต้องจะเรียกว่าโปรแกรมที่ปลอดภัยต่อเธรด (thread-safe )

การสื่อสารการส่งข้อความ

ส่วนประกอบที่ทำงานพร้อมกันจะสื่อสารกันโดยการส่งข้อความ (การแลกเปลี่ยนข้อความ ตัวอย่างเช่นMPI , Go , Scala , Erlangและoccam ) การแลกเปลี่ยนข้อความอาจดำเนินการแบบอะซิงโครนัส หรืออาจใช้รูปแบบ "การนัดพบ" แบบซิงโครนัสซึ่งผู้ส่งจะบล็อกจนกว่าจะได้รับข้อความ การส่งข้อความแบบอะซิงโครนัสอาจเชื่อถือได้หรือไม่น่าเชื่อถือ (บางครั้งเรียกว่า "ส่งแล้วภาวนา") การทำงานพร้อมกันโดยการส่งข้อความมักจะเข้าใจได้ง่ายกว่าการทำงานพร้อมกันโดยใช้หน่วยความจำร่วมกัน และโดยทั่วไปถือว่าเป็นรูปแบบการเขียนโปรแกรมพร้อมกันที่แข็งแกร่งกว่า^{[ 11 ]}มีทฤษฎีทางคณิตศาสตร์มากมายให้เลือกใช้เพื่อทำความเข้าใจและวิเคราะห์ระบบการส่งข้อความ รวมถึงแบบจำลองแอคเตอร์และแคลคูลัสกระบวนการ ต่างๆ การส่งข้อความสามารถนำไปใช้ได้อย่างมีประสิทธิภาพผ่านการประมวลผลแบบมัลติโปรเซสซิ่งแบบสมมาตร โดยมีหรือไม่มี ความสอดคล้องของแคชหน่วยความจำร่วมกัน

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

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

การศึกษาเชิงวิชาการเกี่ยวกับอัลกอริทึมแบบขนานเริ่มต้นขึ้นในช่วงทศวรรษ 1960 โดยDijkstra (1965)ได้รับการยกย่องว่าเป็นผู้เขียนบทความแรกในสาขานี้ โดยระบุและแก้ไขปัญหาการกีดกันร่วมกัน^{[ 12 ]}

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

ในระดับภาษาโปรแกรม:

• ช่อง
• โครูทีน
• อนาคตและคำสัญญา

ในระดับระบบปฏิบัติการ:

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

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

ภาษาการเขียนโปรแกรมแบบขนานคือภาษาการเขียนโปรแกรมที่ใช้โครงสร้างภาษาสำหรับการทำงานแบบขนานโครงสร้างเหล่านี้อาจเกี่ยวข้องกับมัลติเธรดดิ้งการสนับสนุนการประมวลผลแบบกระจายการส่งข้อความทรัพยากรที่ใช้ร่วม กัน (รวมถึงหน่วยความจำที่ใช้ร่วมกัน ) หรือฟิวเจอร์และโพรมีสภาษาดังกล่าวบางครั้งเรียกว่าภาษาที่มุ่งเน้นการทำงานแบบขนานหรือภาษาการเขียนโปรแกรมที่มุ่งเน้นการทำงานแบบขนาน (COPL) ^{[ 13 ]}

ในปัจจุบัน ภาษาโปรแกรมที่ใช้กันทั่วไปซึ่งมีโครงสร้างเฉพาะสำหรับการทำงานพร้อมกัน (concurrency) คือJavaและC#ทั้งสองภาษานี้ใช้โมเดลการทำงานพร้อมกันแบบหน่วยความจำร่วม (shared-memory concurrency model) โดยพื้นฐานแล้ว โดยใช้มอนิเตอร์ (monitor ) ในการล็อก (แม้ว่าโมเดลการส่งข้อความ (message-passing model) สามารถและเคยถูกนำมาใช้บนโมเดลหน่วยความจำร่วมพื้นฐานนี้แล้วก็ตาม) ในบรรดาภาษาที่ใช้โมเดลการทำงานพร้อมกันแบบส่งข้อความนั้นErlangน่าจะเป็นภาษาที่ใช้กันอย่างแพร่หลายที่สุดในอุตสาหกรรมในปี 2010

ภาษาโปรแกรมแบบขนานหลายภาษาได้รับการพัฒนาขึ้นเพื่อใช้ในการวิจัย (เช่นPict ) มากกว่าที่จะใช้ในอุตสาหกรรมการผลิต อย่างไรก็ตาม ภาษาอย่างErlang , Limboและoccamก็เคยถูกนำไปใช้ในอุตสาหกรรมในช่วง 20 ปีที่ผ่านมา รายชื่อภาษาที่ใช้หรือมีคุณสมบัติในการเขียนโปรแกรมแบบขนาน (แต่ไม่ครบถ้วนสมบูรณ์):

• Adaเป็นภาษาโปรแกรมอเนกประสงค์ รองรับการส่งข้อความและการทำงานพร้อมกันโดยใช้มอนิเตอร์ได้อย่างมีประสิทธิภาพ
• Alef – การเขียนโปรแกรมระบบแบบขนาน โดยใช้เธรดและการส่งข้อความ ในเวอร์ชันแรกๆ ของPlan 9 จาก Bell Labs
• Alice – ส่วนขยายของStandard MLเพิ่มการรองรับการทำงานพร้อมกันผ่านฟิวเจอร์ส
• Ateji PX – ส่วนขยายของJavaที่มีฟังก์ชันพื้นฐานแบบขนาน ซึ่งได้รับแรงบันดาลใจจากแคลคูลัส π
• Axum – โซลูชันเฉพาะโดเมนที่ทำงานพร้อมกันได้ โดยใช้โมเดล Actor และ .NET Common Language Runtime พร้อมไวยากรณ์คล้ายภาษา C
• เครื่องจักรการไหลของข้อมูลแบบโมดูลาร์ไบนารี (BMDFM)
• C++ – ไลบรารีสนับสนุนเธรดและโครูทีน^{[ 14 ] [ 15 ]}
• Cω (C omega) – สำหรับงานวิจัย ขยายขีดความสามารถของ C# และใช้การสื่อสารแบบอะซิงโครนัส
• C# – รองรับการประมวลผลพร้อมกันโดยใช้lock , yieldและตั้งแต่เวอร์ชัน 5.0 เป็นต้นมาได้มีการเพิ่มคีย์เวิร์ดasyncและawait เข้ามาด้วย
• Clojure – ภาษาโปรแกรมเชิงฟังก์ชันสมัยใหม่ ที่พัฒนามาจาก ภาษา Lispบนแพลตฟอร์มJava
• Concurrent Clean – การเขียนโปรแกรมเชิงฟังก์ชัน คล้ายกับHaskell
• Concurrent Collections (CnC) – บรรลุถึงการทำงานแบบขนานโดยปริยายโดยไม่ขึ้นอยู่กับรูปแบบหน่วยความจำ ด้วยการกำหนดการไหลของข้อมูลและการควบคุมอย่างชัดเจน
• Haskell แบบขนาน – ภาษาเชิงฟังก์ชันบริสุทธิ์แบบ lazy ที่ทำงานกับกระบวนการแบบขนานบนหน่วยความจำร่วมกัน
• ML แบบพร้อมกัน – ส่วนขยายแบบพร้อมกันของML มาตรฐาน
• ปาสคาลแบบพร้อมกัน – โดยเพอร์ บรินช์ แฮนเซน
• แกง
• D – ภาษาการเขียนโปรแกรมระบบแบบหลายกระบวนทัศน์ พร้อมการสนับสนุนอย่างชัดเจนสำหรับการเขียนโปรแกรมแบบขนาน ( โมเดลแอคเตอร์ )
• E – ใช้คำมั่นสัญญาเพื่อป้องกันภาวะชะงักงัน
• ECMAScript – ใช้ Promise สำหรับการทำงานแบบอะซิงโครนัส
• Eiffel – ด้วย กลไก SCOOPที่อิงตามแนวคิดการออกแบบตามสัญญา (Design by Contract)
• Elixir – ภาษาโปรแกรมแบบไดนามิกและเชิงฟังก์ชันที่รองรับเมตาโปรแกรมมิง ทำงานบน Erlang VM โดยใช้การส่งข้อความแบบอะซิงโครนัสโดยไม่มีหน่วยความจำที่ใช้ร่วมกัน
• Erlang – ภาษาโปรแกรมแบบไดนามิกและเชิงฟังก์ชันที่ทำงานบน Erlang VM ซึ่งใช้การส่งข้อความแบบอะซิงโครนัสโดยไม่มีหน่วยความจำที่ใช้ร่วมกัน
• FAUST – คอมไพเลอร์สำหรับประมวลผลสัญญาณแบบเรียลไทม์เชิงฟังก์ชัน ให้การทำงานแบบขนานอัตโนมัติผ่านOpenMP หรือ ตัวจัดตารางงานแบบขโมยงานเฉพาะ
• Fortran – คำสั่ง coarraysและdo concurrentเป็นส่วนหนึ่งของมาตรฐาน Fortran 2008
• Go – เหมาะสำหรับการเขียนโปรแกรมระบบ โดยใช้โมเดลการเขียนโปรแกรมแบบขนานบนพื้นฐานของกระบวนการลำดับการสื่อสาร (CSP)
• Haskell – ภาษาการเขียนโปรแกรมเชิงฟังก์ชันแบบพร้อมกันและแบบขนาน^{[ 16 ]}
• ฮิวม์ – ทฤษฎีฟังก์ชันแบบขนาน สำหรับสภาพแวดล้อมที่มีขอบเขตจำกัดทั้งด้านพื้นที่และเวลา โดยที่กระบวนการอัตโนมัติจะถูกอธิบายด้วยรูปแบบช่องสัญญาณแบบซิงโครนัสและการส่งข้อความ
• Io – การทำงานพร้อมกันแบบอิงตามแอคเตอร์
• Janus – มีคุณสมบัติเด่นคือมีผู้ถามและผู้บอกข้อมูล ที่แตกต่างกัน สำหรับตัวแปรเชิงตรรกะ และช่องทางกระเป๋าข้อมูล เป็นภาษาเชิงประกาศล้วนๆ
• Java – คลาสเธรดหรืออินเทอร์เฟซ Runnable
• Julia – พรีมิทีฟการเขียนโปรแกรมแบบขนาน: งาน, async-wait, ช่องสัญญาณ^{[ 17 ]}
• JavaScript – ผ่านทางWeb Workersในสภาพแวดล้อมของเบราว์เซอร์, PromisesและCallbacks
• JoCaml – ส่วนขยายของ OCamlที่ใช้ช่องทางแบบขนานและแบบกระจายและใช้แคลคูลัสการรวมกระบวนการ
• Join Java – การประมวลผลแบบขนาน โดยใช้ภาษาJava เป็นพื้นฐาน
• Joule – ระบบที่ใช้การไหลของข้อมูล สื่อสารโดยการส่งข้อความ
• Joyce – แพลตฟอร์มการเรียนรู้แบบขนาน สำหรับการสอน สร้างขึ้นบนConcurrent Pascalพร้อมคุณสมบัติจากCSPโดยPer Brinch Hansen
• LabVIEW – เป็นแบบกราฟิก ควบคุมการไหลของข้อมูล ฟังก์ชันเปรียบเสมือนโหนดในกราฟ และข้อมูลเปรียบเสมือนสายไฟที่เชื่อมต่อระหว่างโหนดต่างๆ รวมถึงภาษาเชิงวัตถุด้วย
• Limbo – ญาติของAlefสำหรับการเขียนโปรแกรมระบบในInferno (ระบบปฏิบัติการ)
• Locomotive BASIC – ภาษา BASIC เวอร์ชัน Amstrad มีคำสั่ง EVERY และ AFTER สำหรับซับรูทีนที่ทำงานพร้อมกัน
• MultiLisp – รูปแบบหนึ่ง ของ Schemeที่ได้รับการพัฒนาเพิ่มเติมเพื่อรองรับการประมวลผลแบบขนาน
• Modula-2 – สำหรับการเขียนโปรแกรมระบบ พัฒนาโดยNiklaus Wirthเพื่อทดแทนPascalโดยมีคุณสมบัติรองรับ coroutines โดยตรง
• Modula-3 – สมาชิกสมัยใหม่ของ ตระกูล ALGOLที่รองรับการทำงานแบบเธรด, มิวเท็กซ์ และตัวแปรเงื่อนไขอย่างครอบคลุม
• Newsqueak – สำหรับการวิจัย โดยเน้นช่องทางที่มีคุณภาพเป็นเลิศ เป็นรุ่นก่อนหน้าของAlef
• occam – ได้รับอิทธิพลอย่างมากจากกระบวนการสื่อสารตามลำดับ (CSP)
  • occam-π – รูปแบบสมัยใหม่ของoccamซึ่งรวมเอาแนวคิดจากแคลคูลัส π ของ Milner เข้าไปด้วย
• Object REXX (ooRexx) – ระบบแลกเปลี่ยนข้อความแบบอิงวัตถุสำหรับการสื่อสารและการซิงโครไนซ์
• Orc – ระบบที่มีการทำงานพร้อมกันสูง ไม่แน่นอน และใช้พีชคณิตคลีน เป็นพื้นฐาน
• Oz-Mozart – รองรับหลายกระบวนทัศน์ รองรับการทำงานพร้อมกันแบบใช้สถานะร่วมกันและการส่งข้อความ และฟิวเจอร์ส
• ParaSail – การเขียนโปรแกรมเชิงวัตถุ ทำงานแบบขนาน ปราศจากตัวชี้ และสภาวะการแข่งขัน
• PHP – รองรับมัลติเธรดด้วยส่วนขยายแบบขนานที่ใช้การส่งข้อความที่ได้รับแรงบันดาลใจจากGo ^{[ 18 ]}
• Pict – โดยพื้นฐานแล้วคือโปรแกรมที่สามารถเรียกใช้งานได้ของแคลคูลัส π ของ Milner
• Python – ใช้การประมวลผลแบบขนานตามเธรดและการประมวลผลแบบขนานตามกระบวนการ^{[ 19 ]}
• Raku – มีคลาสสำหรับเธรด สัญญา และช่องสัญญาณโดยค่าเริ่มต้น^{[ 20 ]}
• Reia – ใช้การส่งข้อความแบบอะซิงโครนัสระหว่างอ็อบเจ็กต์ที่ไม่มีการแชร์ข้อมูล
• Red/System – สำหรับการเขียนโปรแกรมระบบ โดยใช้Rebol เป็นพื้นฐาน
• Rust – สำหรับการเขียนโปรแกรมระบบ โดยใช้การส่งข้อความด้วยความหมายของการย้าย และหน่วยความจำที่ใช้ร่วมกัน (ไม่เปลี่ยนแปลงและเปลี่ยนแปลงได้) ^{[ 21 ]}
• Scala – ภาษาโปรแกรมอเนกประสงค์ ออกแบบมาเพื่อแสดงรูปแบบการเขียนโปรแกรมทั่วไปอย่างกระชับ สวยงาม และปลอดภัยในด้านชนิดข้อมูล
• SequenceLเป็นภาษาโปรแกรมอเนกประสงค์ที่ออกแบบมาเพื่อการเขียนโปรแกรมที่ง่าย ชัดเจน และอ่านง่าย มีการประมวลผลแบบขนานอัตโนมัติเพื่อเพิ่มประสิทธิภาพบนฮาร์ดแวร์แบบมัลติคอร์ และปราศจากปัญหา Race Condition อย่างแน่นอน
• SR – สำหรับการวิจัย
• SuperPascal – ระบบการเรียนรู้แบบขนาน สำหรับการสอน สร้างขึ้นบนพื้นฐานของConcurrent PascalและJoyceโดยPer Brinch Hansen
• Swift – รองรับการเขียนโค้ดแบบอะซิงโครนัสและขนานในรูปแบบที่มีโครงสร้าง^{[ 22 ]}
• ยูนิคอน – เพื่อการวิจัย
• ภาษากำหนดคุณสมบัติและคำอธิบายของ TeleNokia ( TNSDL ) – สำหรับการพัฒนาระบบแลกเปลี่ยนโทรคมนาคม โดยใช้การส่งข้อความแบบอะซิงโครนัส
• ภาษาอธิบายฮาร์ดแวร์ VHSIC ( VHDL ) – มาตรฐาน IEEE STD-1076
• XC – ชุดย่อยของภาษา C ที่ขยายเพิ่มเติมเพื่อรองรับการทำงานพร้อมกัน พัฒนาโดยXMOSโดยอิงจากกระบวนการแบบลำดับที่สื่อสารกันและมีโครงสร้างในตัวสำหรับอินพุต/เอาต์พุตที่ตั้งโปรแกรมได้

ภาษาโปรแกรมอื่นๆ อีกมากมายให้การสนับสนุนการทำงานแบบขนานในรูปแบบของไลบรารีซึ่งมีระดับความรองรับใกล้เคียงกับรายการข้างต้น

• อินพุต/เอาต์พุตแบบอะซิงโครนัส
• พื้นที่ชู
• การเขียนโปรแกรมตามกระแส
• Java ConcurrentMap
• โครงการปโตเลมี
• เงื่อนไขการแข่งขัน § การคำนวณ
• การทำงานพร้อมกันแบบมีโครงสร้าง
• การประมวลผลธุรกรรม

• Dijkstra, EW (1965). "การแก้ปัญหาในการควบคุมการเขียนโปรแกรมพร้อมกัน" . Communications of the ACM . 8 (9): 569. doi : 10.1145/365559.365617 . S2CID  19357737 .
• Herlihy, Maurice (2008) [2008]. ศิลปะแห่งการเขียนโปรแกรมมัลติโปรเซสเซอร์ . Morgan Kaufmann. ISBN 978-0123705914.
• ดาวนีย์, อัลเลน บี. (2005) [2005]. หนังสือเล่มเล็กเกี่ยวกับสัญญาณธง (PDF)สำนักพิมพ์กรีนทีเพรสISBN 978-1-4414-1868-5เก็บถาวรจากต้นฉบับ(PDF)เมื่อวันที่ 4 มีนาคม 2016 เรียกดูเมื่อวันที่ 21 พฤศจิกายน 2009
• ฟิลแมน, โรเบิร์ต อี.; แดเนียล พี. ฟรีดแมน (1984). การประมวลผลแบบประสานงาน: เครื่องมือและเทคนิคสำหรับซอฟต์แวร์แบบกระจาย . นิวยอร์ก: แมคกรอว์-ฮิลล์.  หน้า370. ISBN 978-0-07-022439-1.
• Leppäjärvi, Jouni (2008). การสำรวจเชิงปฏิบัติและเชิงประวัติศาสตร์เกี่ยวกับความเป็นสากลขององค์ประกอบพื้นฐานของการซิงโครไนซ์ (PDF)มหาวิทยาลัยโออูลู เก็บถาวรจากต้นฉบับ(PDF)เมื่อ 30 สิงหาคม 2017 สืบค้นเมื่อ 13 กันยายน2012
• Taubenfeld, Gadi (2006). อัลกอริทึมการซิงโครไนซ์และการเขียนโปรแกรมแบบขนาน . Pearson / Prentice Hall. หน้า 433. ISBN 978-0-13-197259-9.

• สื่อที่เกี่ยวข้องกับการเขียนโปรแกรมแบบขนานในวิกิมีเดียคอมมอนส์
• ห้องสมุดเสมือนระบบพร้อมกัน