ภาษาการเขียนโปรแกรมสมัยใหม่พร้อม abstractions การเขียนโปรแกรมพร้อมกันที่ใช้งานง่าย [ปิด]

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

เพื่อยกตัวอย่างบางอย่างฉันไม่พิจารณาตัวเลือกที่ดีในการเขียนโค้ดแบบมัลติเธรดใน C, C ++ หรือ Java เพราะ IMHO ลดประสิทธิภาพของฉันลงและรูปแบบการเขียนโปรแกรมของพวกเขาไม่ง่าย ในทางกลับกันภาษาที่เพิ่มประสิทธิภาพและเสนอ abstractions ที่ใช้งานง่ายเช่น Python และโมดูลหลายตัวประมวลผล, Erlang, Clojure, Scala ฯลฯ จะเป็นตัวเลือกที่ดี

คุณอยากแนะนำอะไรจากประสบการณ์ของคุณและเพราะอะไร

แก้ไข: ขอบคุณทุกคนสำหรับคำตอบที่น่าสนใจของคุณ เป็นการยากที่จะสรุปโดยไม่ต้องพยายามจริง ๆ เนื่องจากมีผู้สมัครที่ดีมากมายเช่น Erlang, Clojure, Scala, Groovy และ Haskell ฉันโหวตคำตอบด้วยข้อโต้แย้งที่น่าเชื่อที่สุด แต่ฉันจะลองผู้สมัครที่ดีทั้งหมดก่อนที่จะตัดสินใจเลือกข้อใดข้อหนึ่ง :)

คุณเกือบจะควรดูClojure - ในความคิดของฉันมันเป็นภาษาสมัยใหม่ที่ดีที่สุดสำหรับการเขียนโปรแกรมแบบมัลติคอร์และมีประสิทธิภาพอย่างมาก

คุณสมบัติที่สำคัญ:

• มันเป็นภาษาที่ใช้งานได้ซึ่งเป็นประโยชน์สำหรับทั้งการเกิดพร้อมกันและความสามารถของคุณในการพัฒนาโดยใช้ abstractions ระดับที่สูงขึ้น มันมีโครงสร้างข้อมูลถาวรไม่เปลี่ยนรูปแบบและลำดับที่ขี้เกียจซึ่งจะคุ้นเคยกับทุกคนที่มีประสบการณ์ในภาษาการทำงานเช่น Haskell
• มันมีระบบหน่วยความจำทรานแซคชั่นของซอฟต์แวร์ที่แปลกใหม่สำหรับการเข้าถึงสถานะที่ไม่แน่นอนที่ล็อคไม่ได้พร้อมกัน การสร้างรหัสการทำงานพร้อมกันที่ปลอดภัยมักจะง่ายเหมือนการห่อในบล็อก (dosync .... )
• มันเป็นเสียงกระเพื่อม - ซึ่งทำให้มีประสิทธิภาพอย่างยิ่งสำหรับการสร้างโปรแกรม metaprogramming แบบมาโครและการสร้างรหัส สิ่งนี้สามารถนำมาซึ่งความได้เปรียบในการผลิตที่สำคัญ(เรียงความโดย Paul Graham - "Beating The A ค่าเฉลี่ย")
• มันเป็นภาษา JVM - ไม่เพียง แต่คุณจะสามารถเข้าถึงไลบรารีและเครื่องมือมากมายในระบบนิเวศ Java คุณยังได้รับประโยชน์จากความพยายามด้านวิศวกรรมขนาดใหญ่ที่ทำให้ JVM เป็นแพลตฟอร์มที่มีประสิทธิภาพสำหรับแอปพลิเคชันฝั่งเซิร์ฟเวอร์พร้อมกัน สำหรับจุดประสงค์ในทางปฏิบัติสิ่งนี้ให้ประโยชน์อย่างมากกับภาษาที่ไม่มีรากฐานเช่นนี้
• มันเป็นแบบไดนามิก - ซึ่งส่งผลให้รหัสรัดกุมมากและผลผลิตจำนวนมาก โปรดทราบว่าคุณสามารถใช้คำแนะนำประเภทคงที่เสริมเพื่อประสิทธิภาพหากจำเป็น
• ภาษาได้รับการออกแบบในแนวนามธรรมซึ่งค่อนข้างยากที่จะอธิบาย แต่ผลกระทบสุทธิคือคุณได้รับชุดของคุณสมบัติมุมฉากที่คุณสามารถรวมเข้าด้วยกันเพื่อแก้ปัญหาของคุณ ตัวอย่างจะเป็นนามธรรมที่เป็นลำดับซึ่งช่วยให้คุณสามารถเขียนรหัสที่เกี่ยวข้องกับทุกประเภทของ "ลำดับ" ของวัตถุ (ซึ่งรวมถึงทุกอย่างจากรายการ, สตริง, อาร์เรย์ Java, ลำดับขี้เกียจอนันต์, บรรทัดที่อ่านจากไฟล์ ฯลฯ )
• มีชุมชนที่ยอดเยี่ยม - มีประโยชน์มีไหวพริบ แต่ที่สำคัญที่สุดคือเน้นไปที่ Clojure โดยทั่วไปคือการ "ทำสิ่งต่างๆให้สำเร็จ"

ตัวอย่างโค้ดขนาดเล็กที่มีการเอียงพร้อมกัน:

;; define and launch a future to execute do-something in another thread
(def a (future (do-something)))

;; wait for the future to finish and print its return value
(println @a)

;; call two functions protected in a single STM transaction
(dosync
  (function-one)
  (function-two))

โดยเฉพาะอย่างยิ่งการดูวิดีโอเหล่านี้อย่างน้อยหนึ่งรายการ:

• http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey
• http://www.infoq.com/presentations/Are-We-There-Yet-Rich-Hickey
• http://www.infoq.com/presentations/Clojure-The-Art-of-Abstraction

คุณสามารถลอง D. มันมีสามรุ่น ฉันขอแนะนำอย่างใดอย่างหนึ่งหรือที่สอง

1. std.concurrency หากคุณใช้โมดูลนี้สำหรับทุกความต้องการของคุณพร้อมกันแล้วการรวมกันของภาษาและห้องสมุดมาตรฐานบังคับให้แยกระหว่างหัวข้อ หัวข้อการสื่อสารส่วนใหญ่ผ่านการส่งข้อความด้วยการสนับสนุนที่ จำกัด สำหรับหน่วยความจำที่ใช้ร่วมกันในทางที่โปรดปราน "ปลอดภัยไว้ก่อน" และไม่อนุญาตการแข่งขันข้อมูลระดับต่ำ น่าเสียดายที่เอกสารประกอบของ std.concurrency จำเป็นต้องได้รับการปรับปรุง แต่ตัวแบบนั้นได้รับการบันทึกไว้ในหนังสือฟรีของหนังสือ Andrei Alexandrescu "The D Programming Language"

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

3. core.threadเป็น wrapper ระดับต่ำบน API เธรดเฉพาะของ OS ทั้ง std.concurrency และ std.parallelism ใช้มันภายใต้ประทุน แต่ฉันจะแนะนำให้ใช้ถ้าคุณกำลังเขียนไลบรารี่ของคุณเองหรือหามุมที่น่าขันที่ไม่สามารถทำได้ดีใน std.parallelism หรือ std .concurrency ไม่มีใครควรใช้สิ่งนี้ระดับต่ำสำหรับการทำงานแบบวันต่อวัน

Erlang เป็นตัวเลือกที่ยอดเยี่ยม แต่สิ่งที่เป็นประโยชน์มากกว่านั้นก็คือ Goซึ่งเป็นภาษาใหม่ของ Google

มันอยู่ไม่ไกลจากภาษาทั่วไปอื่น ๆ ดังนั้นจึงเป็นเรื่องง่ายถ้าคุณรู้ภาษาอื่น ๆ ที่ 'ง่าย' อยู่แล้ว หลายคนเปรียบเทียบกับ Python หรือ Lua ในแง่ของ 'ความสะดวกสบาย' ในการเขียนโปรแกรม

ดูการเขียนโปรแกรมแบบขนานของ Microsoft สำหรับ. net มันใช้งานง่ายมาก

คอมพิวเตอร์ส่วนบุคคลและเวิร์กสเตชันจำนวนมากมีสองหรือสี่คอร์ (นั่นคือซีพียู) ที่เปิดใช้งานหลายเธรดที่จะดำเนินการพร้อมกัน คอมพิวเตอร์ในอนาคตอันใกล้คาดว่าจะมีแกนหลักมากขึ้น เพื่อใช้ประโยชน์จากฮาร์ดแวร์ของวันนี้และพรุ่งนี้คุณสามารถขนานรหัสของคุณเพื่อกระจายงานข้ามโปรเซสเซอร์หลายตัว ในอดีตการขนานต้องมีการจัดการเธรดและล็อคระดับต่ำ Visual Studio 2010 และ. NET Framework 4 ปรับปรุงการสนับสนุนสำหรับการเขียนโปรแกรมแบบขนานโดยการให้รันไทม์ใหม่ประเภทไลบรารีคลาสใหม่และเครื่องมือวินิจฉัยใหม่ คุณสมบัติเหล่านี้ทำให้การพัฒนาแบบขนานง่ายขึ้นเพื่อให้คุณสามารถเขียนโค้ดแบบขนานที่มีประสิทธิภาพละเอียดและปรับขนาดได้ในสำนวนธรรมชาติโดยไม่ต้องทำงานกับเธรดหรือเธรดพูลโดยตรง

ทั้ง Erlang และ Scala มีการทำงานพร้อมกันโดยมีนักแสดงซึ่งฉันพบว่าใช้งานง่ายและเรียนรู้ได้ง่าย

นักแสดงในสาขาวิทยาศาสตร์คอมพิวเตอร์เป็นแบบจำลองทางคณิตศาสตร์ของการคำนวณพร้อมกันที่ถือว่า "นักแสดง" เป็นพื้นฐานดั้งเดิมของการคำนวณแบบดิจิตอลพร้อมกัน: ในการตอบสนองต่อข้อความที่ได้รับนักแสดงสามารถตัดสินใจในท้องถิ่นสร้างนักแสดงมากขึ้นส่งข้อความมากขึ้น และกำหนดวิธีการตอบสนองต่อข้อความถัดไปที่ได้รับ ... มันถูกใช้ทั้งเป็นกรอบสำหรับความเข้าใจเชิงทฤษฎีของการคำนวณและเป็นพื้นฐานทางทฤษฎีสำหรับการใช้งานจริงหลายระบบพร้อมกัน

ตอนนี้ฉันกำลังเรียนรู้เกี่ยวกับ Haskell และการอ่านบทความนี้ทำให้ฉันเชื่อว่า Haskell เป็นตัวเลือกที่ดีสำหรับการเขียนโปรแกรมพร้อมกัน เนื่องจากมันทำงานได้อย่างหมดจด (ระบบประเภทรู้ว่าฟังก์ชั่นทำหน้าที่ป้อนข้อมูลเอาท์พุทหรืออ่าน / แก้ไขสถานะโลก) จึงสามารถทำสิ่งต่าง ๆ เช่น Software Transactional Memory (สรุปได้ดีมากในกระดาษด้านบน) ซึ่งทำงานคล้ายกับธุรกรรม ในฐานข้อมูล - คุณได้รับสิ่งดี ๆ มากมายเช่นอะตอมมิกซิตี้ที่มีน้ำตาลเพิ่มขึ้นเล็กน้อย AFAIK, เธรด Haskell มีน้ำหนักเบามากเช่นกัน นอกเหนือจากสิ่งเหล่านี้แล้วความจริงที่ว่า Haskell นั้นมีฟังก์ชั่นล้วนๆช่วยให้งานง่าย ๆ สามารถทำงานคู่ขนานกับคำหลักเดียว (par) แหล่ง

ภาษา GO ของ Google มีเครื่องมือที่น่าสนใจสำหรับการทำงานพร้อมกันซึ่งจะเป็นอีกเรื่องที่น่าลอง ดู: http://golang.org/doc/effective_go.html#concurrencyและอ่านตัวอย่างเล็กน้อย

การเขียนโปรแกรมพร้อมกันเป็นหัวข้อที่มีขนาดใหญ่และมีพื้นที่สำหรับไฮไลต์ Go-specific บางรายการเท่านั้น

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

อย่าสื่อสารด้วยการแบ่งปันหน่วยความจำ แบ่งปันความทรงจำแทนด้วยการสื่อสาร

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

วิธีหนึ่งในการคิดเกี่ยวกับโมเดลนี้คือการพิจารณาโปรแกรมเธรดเดี่ยวทั่วไปที่รันบน CPU ตัวเดียว ไม่จำเป็นต้องมีการซิงโครไนซ์ดั้งเดิม ตอนนี้เรียกใช้อีกเช่น มันก็ไม่จำเป็นต้องประสาน ทีนี้ให้คนทั้งสองสื่อสารกัน หากการสื่อสารเป็นตัวซิงโครไนซ์ก็ไม่จำเป็นต้องทำการซิงโครไนซ์อื่น ยกตัวอย่างเช่น Unix pipelines พอดีกับรุ่นนี้อย่างสมบูรณ์แบบ ถึงแม้ว่าแนวทางของ Go ในการทำงานพร้อมกันนั้นมาจากกระบวนการสื่อสารแบบต่อเนื่องของ Hoare (CSP) แต่ก็สามารถมองเห็นได้ว่าเป็นลักษณะทั่วไปที่ปลอดภัยสำหรับประเภทของท่อ Unix ...

ในรุ่นถัดไป C # ทำให้ง่ายยิ่งขึ้นกว่าแผนภาพที่แสดง มีคำหลักใหม่สองคำคือ Async และ Await

Async ใช้เป็นตัวดัดแปลงฟังก์ชั่นและบอกว่า "การดำเนินการนี้จะทำงานในเธรดอื่น

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

นอกจากนี้การดำเนินการซิงโครไนซ์กับเธรดการโทร (ดังนั้นหากคุณกำลังดำเนินการ asynch เพื่อตอบสนองต่อการคลิกปุ่มคุณไม่จำเป็นต้องโพสต์กลับไปที่เธรด UI ด้วยตนเอง) คำหลักสองคำเล็ก ๆ และคุณจะได้รับพลังการทำงานพร้อมกันเป็นจำนวนมาก อ่านเพิ่มเติมได้ที่นี่

ฉันยังคงแนะนำ C ++ มันเป็นมากกว่าความสามารถของ abstractions ที่จำเป็นในการเขียนรหัสพร้อมกันที่ดี ความน่าจะเป็นอย่างยิ่งที่คุณมีห้องสมุดที่ไม่ดีสำหรับการทำงานเนื่องจากห้องสมุดที่ดีสำหรับการทำงานนั้นค่อนข้างใหม่และแน่นอนว่าความรู้ในการใช้ C ++ นั้นไม่เหมือนกัน TBB ของ Intel นั้นใช้เวลาเพียงไม่กี่ปีและ PPL ของ Microsoft นั้นได้ส่งมอบมาตั้งแต่ปีที่แล้วเท่านั้น

หากคุณใช้สิ่งที่ต้องการ TBB หรือ PPL แล้วรหัสพร้อมกันคือดีไม่ว่าเล็ก ๆ น้อย ๆที่จะเขียนตราบเท่าเห็นพ้องที่จะไม่จิ๊บจ๊อย แต่ยังห่างไกลจากความยากลำบาก ถ้าคุณใช้ pthreads หรือ Win32 threads โดยตรงไม่น่าแปลกใจเลยว่าคุณไม่ชอบ - คุณกำลังเขียนในแอสเซมเบลอร์ด้วยฟังก์ชันดังกล่าว แต่ด้วย PPL แล้วคุณกำลังพูดถึงอัลกอริธึมการทำงานมาตรฐานที่ขนานกับคุณโครงสร้างข้อมูลทั่วไปสำหรับการเข้าถึงพร้อมกันและสิ่งที่ดี

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

ฉันอยากจะแนะนำGroovy / Java / GParsหากคุณสามารถใช้ JVM ได้เพราะมันอนุญาตให้นักแสดง, dataflow, การสื่อสารกระบวนการลำดับ (CSP), ข้อมูลขนาน, หน่วยความจำ transactional ซอฟต์แวร์ (STM), ตัวแทน, ... จุดที่นี่คือว่ามี เป็นรูปแบบการทำงานพร้อมกันในระดับสูงและแบบคู่ขนานซึ่งแต่ละอันมี "จุดที่น่าสนใจ" ที่แตกต่างกัน คุณไม่ต้องการใช้แบบจำลองที่ไม่สอดคล้องกับวิธีแก้ไขปัญหาที่คุณพยายามสร้าง ภาษาและเฟรมเวิร์กที่มีเพียงหนึ่งโมเดลบังคับให้คุณทำการแฮ็กอัลกอริทึม

แน่นอนฉันอาจถูกมองว่าลำเอียงในขณะที่ฉันมีส่วนร่วมกับ Groovy และ GPars ในทางกลับกันฉันทำงานกับ CSP และ Python, cf งูหลาม-CSP

ประเด็นต่อไปคือคำถามดั้งเดิมเกี่ยวกับการเรียนรู้ไม่ใช่เกี่ยวกับการเขียนระบบการผลิต ดังนั้นการรวมกันของ Groovy / Java / GPars จึงเป็นวิธีที่ดีในการเรียนรู้แม้ว่างานการผลิตในท้ายที่สุดจะเสร็จสิ้นใน C ++ โดยใช้สิ่งอย่าง Just :: Thread Pro หรือ TBB แทนที่จะเป็น JVM

(ลิงก์ URL ที่เหมาะสมอย่างสมบูรณ์บางส่วนต้องถูกลบออกเนื่องจากความตื่นตระหนกเกี่ยวกับสแปมไซต์โฮสต์

แล้ว Clojure ล่ะ คุณสามารถใช้ Swing ได้ แต่เพลิดเพลินกับโปรแกรมอำนวยความสะดวกการเขียนโปรแกรม Clojure พร้อมกัน? Clojure มีการรวม Java ค่อนข้างดี

คุณเคยพิจารณากรอบงาน Java 7 Fork / Joinบ้างหรือไม่?

คุณอาจต้องการดูGroovyและไลบรารีGPars GPars BTW ค่อนข้างคล้ายกับ. NET Parallel Extension ที่กล่าวถึงในคำตอบอื่น แต่ไวยากรณ์ที่ยืดหยุ่นของ Groovys ทำให้อ่านได้ดีขึ้นในบางสถานการณ์

Scala ได้ถูกกล่าวถึงหลายครั้งในคำถามและคำตอบ แต่ฉันไม่เคยเห็นการอ้างอิงถึงAkkaซึ่งเป็นการใช้งานของนักแสดงที่สามารถใช้ได้กับทั้ง Scala และ Java

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

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

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

ค้นหาห้องสมุดที่ดีกระบวนการย่อยเช่นทูตสำหรับหลาม หรือคุณสามารถเขียนหลาย ๆ โปรแกรมใน C และเขียนโปรแกรม "master" อีกอันเพื่อใช้fork และ pipeเพื่อวางไข่และสื่อสารกับ subprocesses