คำถามติดแท็ก concurrency

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

17 concurrency 

"การก่อสร้างสากล" เป็นคลาส wrapper สำหรับวัตถุตามลำดับที่ทำให้มันเป็นเส้นตรง (เงื่อนไขความมั่นคงที่แข็งแกร่งสำหรับวัตถุที่เกิดขึ้นพร้อมกัน) ตัวอย่างเช่นนี่คือโครงสร้างที่ปราศจากการรอที่ปรับใช้แล้วใน Java จาก [1] ซึ่งทึกทักว่ามีคิวรอที่ปราศจากการรอWFQซึ่งเป็นไปตามSequentialอินเทอร์เฟซ public interface WFQ<T> // "FIFO" iteration { int enqueue(T t); // returns the sequence number of t Iterable<T> iterateUntil(int max); // iterates until sequence max } public interface Sequential { // Apply an invocation (method + arguments) // and get …

16 java  multithreading  concurrency 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ปิดให้บริการใน4 ปีที่แล้ว ล็อคแล้ว คำถามนี้ไม่ยอมรับคำตอบหรือการโต้ตอบใหม่ เรียนรู้เพิ่มเติม ฉันรู้ว่าฉันมีช่องว่างความรู้อย่างมากเมื่อพูดถึงแอพพลิเคชั่นแบบมัลติเธรดและการเขียนโปรแกรมพร้อมกัน ฉันได้ครอบคลุมพื้นฐานบางอย่างในอดีต แต่ดูเหมือนว่าส่วนใหญ่จะหายไปจากใจของฉันและมันก็เป็นเรื่องที่ฉันต้องการและจำเป็นต้องมีความรู้มากขึ้น แหล่งข้อมูลที่ดีที่สุดสำหรับการเรียนรู้เกี่ยวกับการสร้างแอปพลิเคชันพร้อมกันคืออะไร ฉันเป็นคนที่มุ่งเน้นการปฏิบัติมากดังนั้นถ้าหนังสือกล่าวว่ามีตัวอย่างที่เป็นรูปธรรมที่ดีกว่า แต่ฉันเปิดให้คำแนะนำ โดยส่วนตัวฉันชอบทำงานใน pseudocode หรือ C ++ และตัวเอียงที่มีต่อการพัฒนาเกมจะดีที่สุด แต่ไม่จำเป็น

16 design  multithreading  concurrency 

ฉันกำลังทำงานเกี่ยวกับการออกแบบแอปพลิเคชันที่ประกอบด้วยสามส่วน: เธรดเดียวที่เฝ้าดูเหตุการณ์บางอย่างที่เกิดขึ้น (การสร้างไฟล์คำขอภายนอก ฯลฯ ) เธรดผู้ปฏิบัติงาน N ที่ตอบสนองต่อเหตุการณ์เหล่านี้โดยการประมวลผล (ผู้ปฏิบัติงานแต่ละกระบวนการและใช้เหตุการณ์เดียวและการประมวลผลอาจใช้เวลาแปรผัน) คอนโทรลเลอร์ที่จัดการเธรดเหล่านั้นและจัดการข้อผิดพลาด (การรีสตาร์ทเธรดการบันทึกผลลัพธ์) แม้ว่านี่จะค่อนข้างพื้นฐานและไม่ยากที่จะนำมาใช้ แต่ฉันก็สงสัยว่ามันจะเป็นวิธีที่ "ถูกต้อง" (ในกรณีที่เป็นรูปธรรมนี้ใน Java แต่คำตอบที่เป็นนามธรรมก็สูงขึ้นเช่นกัน) กลยุทธ์ทั้งสองมาถึงใจ: ผู้สังเกตการณ์ / สังเกตได้:ผู้สังเกตการณ์จะเฝ้าสังเกตด้ายดู ในกรณีที่มีเหตุการณ์เกิดขึ้นคอนโทรลเลอร์จะได้รับแจ้งและสามารถมอบหมายงานใหม่ให้กับเธรดอิสระจากกลุ่มเธรดแคชที่ใช้ซ้ำได้ (หรือรอและแคชงานในคิว FIFO หากเธรดทั้งหมดไม่ว่างในขณะนี้) เธรดผู้ปฏิบัติงานใช้ Callable และส่งคืนผลลัพธ์ที่สำเร็จพร้อมกับผลลัพธ์ (หรือค่าบูลีน) หรือส่งคืนพร้อมข้อผิดพลาดในกรณีนี้ผู้ควบคุมอาจตัดสินใจว่าจะทำอย่างไร (ขึ้นอยู่กับลักษณะของข้อผิดพลาดที่เกิดขึ้น) ผู้ผลิต / ผู้บริโภค : เธรดการเฝ้าดูที่ใช้ร่วมกัน BlockingQueue กับตัวควบคุม (เหตุการณ์คิว) และตัวควบคุมที่ใช้ร่วมกันสองกับคนงานทั้งหมด (งานคิวและผลคิว) ในกรณีที่เกิดเหตุการณ์ด้ายเฝ้าดูทำให้วัตถุงานในคิวเหตุการณ์ คอนโทรลเลอร์ใช้งานใหม่จาก event-queue ตรวจสอบและวางไว้ใน task-queue ผู้ปฏิบัติงานแต่ละคนรองานใหม่และรับ / ใช้งานจากคิวงาน (มาก่อนได้รับก่อนจัดการโดยคิวเอง) …

15 java  architecture  concurrency  observer-pattern  producer-consumer 

ฉันมักจะอ่านว่าการขนานและการเกิดพร้อมกันเป็นสิ่งที่แตกต่างกัน บ่อยครั้งที่ผู้ตอบ / ผู้แสดงความคิดเห็นไปถึงเท่าที่เขียนว่าพวกเขาทั้งสองแตกต่างกันอย่างสิ้นเชิง แต่ในมุมมองของฉันพวกเขาเกี่ยวข้องกัน แต่ฉันต้องการความกระจ่างเกี่ยวกับเรื่องนี้ ตัวอย่างเช่นถ้าผมอยู่บนซีพียูแบบมัลติคอร์และการบริหารจัดการที่จะแบ่งการคำนวณลงในxคำนวณขนาดเล็ก (พูดโดยใช้ส้อม / เข้าร่วม) แต่ละทำงานในหัวข้อของตัวเองฉันจะมีโปรแกรมที่มีทั้งการทำเช่นการคำนวณแบบขนาน (เพราะ ในเวลาใดก็ตามหลายเธรดจะทำงานในหลายคอร์) และพร้อมกันใช่ไหม? ในขณะที่ถ้าฉันเพียงแค่ใช้พูด Java และจัดการกับเหตุการณ์ UI และ repaints บน Event Dispatch Thread บวกกับการรันเธรดเดียวที่ฉันสร้างขึ้นเองฉันจะมีโปรแกรมที่ทำงานพร้อมกัน (EDT + GC เธรด + เธรดหลักของฉัน ฯลฯ ) แต่ไม่ขนาน ฉันต้องการที่จะรู้ว่าฉันได้รับสิทธินี้และหากการขนาน (ในระบบ "เดี่ยว แต่หลายแกน") หมายถึงการทำงานพร้อมกันหรือไม่? นอกจากนี้ยังมีโปรแกรมแบบมัลติเธรดที่ทำงานบนซีพียูหลายคอร์ แต่ที่ที่เธรดต่างกันกำลังทำการคำนวณที่แตกต่างกันโดยสิ้นเชิงซึ่งถือว่าเป็นการใช้ "การขนาน"?

15 multithreading  concurrency  parallelism  definition 

ดูบทความนี้เกี่ยวกับความปลอดภัยของการเกิดพร้อมกันของ Rust: http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html ฉันสงสัยว่าความคิดเหล่านี้สามารถทำได้ใน C ++ 11 (หรือใหม่กว่า) โดยเฉพาะอย่างยิ่งฉันสามารถสร้างคลาสของเจ้าของที่โอนความเป็นเจ้าของไปยังวิธีการใด ๆ ที่มันอาจจะผ่าน? ดูเหมือนว่า C ++ มีหลายวิธีในการส่งผ่านตัวแปรที่เป็นไปไม่ได้ แต่บางทีฉันอาจวางข้อ จำกัด บางอย่างในคลาสหรือเทมเพลตเพื่อให้แน่ใจว่าโค้ดเทมเพลตบางตัวได้รับการประมวลผลด้วยวิธีการส่งผ่านทุกครั้งหรือไม่

15 concurrency  c++11  rust 

รับระบบซึ่งให้: การควบคุมพร้อมกันในแง่ดีที่สุด / การกำหนดเวอร์ชันต่อวัตถุ (ใช้ CAS - ตรวจสอบและตั้งค่า) ธุรกรรมที่ไม่จำเป็นต้องมีการขยายเพิ่มเติมจากวัตถุเดียว การแยก Snapshot ระบบนี้ถือว่าเป็นอนุกรมหรือไม่ จากการแยก Snapshot ในการเขียนที่ผิดปกติธุรกรรมสองรายการ (T1 และ T2) พร้อมกันอ่านชุดข้อมูลที่ทับซ้อนกัน (เช่นค่า V1 และ V2) ทำการอัปเดตร่วมกัน (เช่นอัปเดต T1 V1, อัปเดต V2 V2) และในที่สุดก็กระทำพร้อมกัน การอัปเดตดำเนินการโดยผู้อื่น เป็นระบบที่ต่อเนื่องกันได้ความผิดปกติดังกล่าวจะเป็นไปไม่ได้เนื่องจาก T1 หรือ T2 จะต้องเกิดขึ้น "เป็นครั้งแรก" และจะเห็นได้จากอีกคนหนึ่ง ในทางตรงกันข้ามการแยกสแน๊ปช็อตอนุญาตให้เขียนความผิดปกติได้ เป็นตัวอย่างที่เป็นรูปธรรมลองนึกภาพ V1 และ V2 เป็นสองยอดดุลที่จัดขึ้นโดยบุคคลคนเดียว Phil ธนาคารจะอนุญาตให้ V1 หรือ V2 …

13 concurrency  distributed-system 

ถ้าฉันเข้าใจโมเดลนักแสดงก็เหมือนโมเดลวัตถุ แต่มีความแตกต่างเล็กน้อย: วัตถุทุกตัวมีเธรดแยกต่างหากและไม่มีปัญหาแม้ว่าคุณจะมีวัตถุนับพัน นักแสดงไม่ได้มีปฏิสัมพันธ์โดยการเรียกฟังก์ชั่นและรับค่าตอบแทน แต่เป็นการส่งและรับข้อความแทน หากคุณไม่ละเมิดรูปแบบดังกล่าวแอปของคุณจะใช้การทำงานพร้อมกันให้เต็มกำลังโดยไม่มีความเสี่ยงจากสภาพการแข่งขัน ทุกสิ่งที่คุณสามารถทำได้ใน OO คุณสามารถใช้นักแสดง แต่ดีกว่าปัญหาที่ว่าทุกอย่างที่เราเขียนในปีที่ผ่านมาเป็น OO แต่การเปลี่ยนแปลงนั้นใกล้เข้ามาแล้ว ตัวอย่างเช่นสมมติว่าฉันต้องกำหนดคลาสเวกเตอร์ 3d / นักแสดงสร้างอินสแตนซ์ที่สองและเรียกใช้การดำเนินการรวมกับพวกเขา วัตถุที่มุ่งเน้น: class V3d { constructor V3d(x,y,z) //bla float x,y,z; function sum(V3d b) { return V3d(x+b.x,y+b.y,z+b.z); } } //using: mySum = V3d(1,2,3).sum(V3d(3,2,1)) //creates 2 instances, sum, returns instantly drawPoint(mySum) //uses the result รุ่นนักแสดง: actor V3d …

13 object-oriented  multithreading  paradigms  concurrency  actor-model 

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

13 concurrency  parallelism 

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

12 performance  multithreading  concurrency 

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

12 compiler  concurrency  computer-science 

ปิด คำถามนี้เป็นคำถามความคิดเห็นตาม ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้สามารถตอบข้อเท็จจริงและการอ้างอิงได้โดยแก้ไขโพสต์นี้ ปิดให้บริการใน6 ปีที่ผ่านมา ในบทความThe Free Lunch Is Overจากปี 2005 Herb Sutter ทำนายการปฏิวัติการเขียนโปรแกรมพร้อมกันว่าใหญ่เท่ากับการปฏิวัติเชิงวัตถุ การปฏิวัติครั้งนี้มีความสุขจริงๆในปี 2005 - 2013 หรือไม่? ประเด็นสำคัญในบทความ: ผู้ผลิตหน่วยประมวลผลหมดพื้นที่ด้วยวิธีการแบบดั้งเดิมส่วนใหญ่เพื่อเพิ่มประสิทธิภาพของ CPU แทนที่จะเพิ่มความเร็วสัญญาณนาฬิกาให้สูงขึ้นพวกเขาจะเปลี่ยนไปใช้สถาปัตยกรรมแบบไฮเปอร์เธรดและมัลติคอร์แทน แอปพลิเคชันจะต้องพร้อมกันมากขึ้นหากต้องการใช้ประโยชน์จากปริมาณงานของ CPU อย่างเต็มที่ “ โอ้ประสิทธิภาพไม่สำคัญเท่าไหร่คอมพิวเตอร์ก็เร็วขึ้นเรื่อย ๆ ” คำสั่งจะผิด ประสิทธิภาพและการเพิ่มประสิทธิภาพจะได้รับมากขึ้นไม่น้อยไปกว่าสิ่งสำคัญ ภาษาเหล่านั้นที่ให้ยืมเพื่อการปรับให้เหมาะสมอย่างหนักจะได้พบกับชีวิตใหม่ ผู้ที่ไม่จำเป็นต้องหาวิธีในการแข่งขันและมีประสิทธิภาพมากขึ้นและปรับให้เหมาะสม คาดว่าความต้องการที่เพิ่มขึ้นในระยะยาวสำหรับภาษาและระบบที่มุ่งเน้นประสิทธิภาพ ภาษาและระบบการเขียนโปรแกรมจะถูกบังคับให้จัดการกับการทำงานพร้อมกันมากขึ้น เราจำเป็นต้องมีรูปแบบการเขียนโปรแกรมระดับสูงสำหรับการทำงานพร้อมกันมากกว่าภาษาที่มีให้ในวันนี้

12 concurrency 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา ต่อไปนี้เป็นคำถามที่ฉันถามผู้สัมภาษณ์เมื่อเร็ว ๆ นี้ว่าพวกเขารู้จักการทำงานพร้อมกันของ Java: อธิบายถึงอันตรายของ "การมองเห็นของหน่วยความจำ" - วิธีที่ JVM สามารถเรียงลำดับการดำเนินการบางอย่างกับตัวแปรที่ไม่ได้รับการป้องกันโดยจอภาพและไม่ได้ประกาศvolatileเช่นว่าเธรดหนึ่งอาจไม่เห็นการเปลี่ยนแปลงของเธรดอื่น ฉันมักจะถามรหัสนี้โดยแสดงรหัสที่อันตรายนี้มีอยู่ ( NoVisibilityตัวอย่างเช่นในรายการ 3.1 จาก "Java Concurrency in Practice" โดย Goetz et al) และถามสิ่งที่ผิด อธิบายว่าvolatileมีผลกระทบอย่างไรกับตัวแปรที่เกิดขึ้นจริงที่ประกาศvolatileแต่ยังรวมถึงการเปลี่ยนแปลงตัวแปรที่ทำโดยเธรดก่อนที่จะเปลี่ยนแปลงvolatileตัวแปร ทำไมคุณอาจใช้volatileแทนsynchronized? ใช้ตัวแปรสภาพด้วยและwait() อธิบายว่าทำไมคุณควรใช้notifyAll() notifyAll()อธิบายว่าทำไมตัวแปรเงื่อนไขควรทดสอบด้วยการwhileวนซ้ำ คำถามของฉันคือ - สิ่งเหล่านี้เหมาะสมหรือสูงเกินไปที่จะถามคนที่บอกว่าพวกเขารู้จักการทำงานพร้อมกันของ Java หรือไม่ และในขณะที่เราอยู่ที่นี่คุณคิดว่าคนที่ทำงานใน Java เห็นพ้องด้วยควรคาดว่าจะมีความรู้สูงกว่าค่าเฉลี่ยของการเก็บขยะ Java?

12 java  interview  concurrency 

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

12 database  concurrency  microservices  data-integrity 

อ่านหนังสือเกี่ยวกับการเห็นพ้องใน Erlang , ทำให้ผมนึกถึงเห็นพ้องด้วยเครื่องมือ Akka ทั้งสองให้คุณมีเครื่องมือในการป้องกันหรือการ จำกัดเงื่อนไขการแข่งขัน แต่คุณสามารถส่งลิงค์ไปยังข้อมูลที่ไม่แน่นอนไปยังกระบวนการอื่น ๆ โดยใช้ชุดเครื่องมือ Akka ซึ่งยังไม่ปลอดภัย ฉันเห็น Akka เป็นเครื่องมือที่มีประโยชน์ แต่ไม่ได้ให้การป้องกันการเข้าถึงวัตถุและข้อมูลที่นำไปสู่สภาวะการแข่งขันการหยุดชะงักและ / หรือความอดอยาก มันไม่ได้ป้องกันคุณจากการเขียนรหัสที่ไม่ปลอดภัยในแบบที่ Java หรือ C # ปกป้องคุณจากการเขียนการรั่วไหลของหน่วยความจำส่วนใหญ่ที่คุณสามารถเขียนใน C ++ (คุณยังสามารถสร้างการรั่วไหลของหน่วยความจำใน Java ได้ด้วยการหลอก ของปัญหามากกว่าการจำให้ฟรีทุกไบต์ที่คุณจัดสรร) Erlang รับประกันความถูกต้องระดับประสิทธิภาพและความทนทานในการเขียนโปรแกรมพร้อมกันหรือไม่? ฉันคิดว่าระบบปฏิบัติการให้ความคุ้มครองเมื่อเข้าถึงทรัพยากรระบบ (สมมติว่าผู้เขียนไดรเวอร์ทำงานได้ดี) ฐานข้อมูล ACID จัดเตรียมการป้องกันสำหรับการอ่านและอัพเดต ดังนั้นดูเหมือนว่านี่เป็นปัญหาที่แก้ไขได้ หรือโซลูชันที่ปลอดภัยทั่วไปจะลบประสิทธิภาพที่ได้จากการทำงานพร้อมกันหรือไม่ ภาษาหรือชุดเครื่องมืออื่นให้ความปลอดภัยพร้อมกันที่ Erlang ทำ (หรือไม่) หรือไม่? นี่เป็นคำถามที่ติดตามความคิดเห็นของ @ Malfist ในคำตอบของ @ user1249 …

11 concurrency  erlang