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

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

107 terminology  concurrency  parallelism 

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

84 concurrency  complexity  concepts  parallelism 

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

79 database  concurrency  sqlite 

ฉันคุ้นเคยกับแนวคิดของการรวมวัตถุและฉันพยายามที่จะใช้มันให้มากที่สุด นอกจากนี้ฉันมักจะคิดว่าการรวมวัตถุเป็นบรรทัดฐานมาตรฐานที่ฉันสังเกตเห็นว่า Java เองรวมถึงกรอบงานอื่น ๆ ที่ใช้ร่วมกันมากที่สุด เมื่อเร็ว ๆ นี้แม้ว่าฉันจะอ่านอะไรบางอย่างที่เป็นของใหม่ การรวมกำไรนั้นทำให้ประสิทธิภาพของโปรแกรมแย่ลงโดยเฉพาะในแอปพลิเคชันที่เกิดขึ้นพร้อมกันและขอแนะนำให้สร้างอินสแตนซ์newวัตถุแทนเนื่องจากใน JVM รุ่นใหม่การสร้างอินสแตนซ์ของวัตถุนั้นเร็วมาก ฉันอ่านสิ่งนี้ในหนังสือ: Java Concurrency in Practice ตอนนี้ฉันเริ่มคิดว่าถ้าฉันเข้าใจบางสิ่งบางอย่างที่นี่ตั้งแต่ส่วนแรกของหนังสือแนะนำให้ใช้Executorsซ้ำนั้นThreadแทนที่จะสร้างอินสแตนซ์ใหม่ การรวมวัตถุได้กลายเป็นที่นิยมในปัจจุบัน?

62 java  design-patterns  java-ee  concurrency 

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

57 multithreading  concurrency 

ผู้วิจารณ์ที่นี่เสนอคำวิจารณ์ต่อไปนี้ของหัวข้อสีเขียว: ตอนแรกฉันขายในโมเดล N: M เพื่อให้มีการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์โดยไม่ต้องโทรกลับนรก คุณสามารถเขียนโค้ดที่ดูเหมือนรหัสขั้นตอนเก่าที่เจ็บปวดได้ แต่ภายใต้มีเวทย์มนตร์ที่ใช้งานการสลับผู้ใช้เมื่อใดก็ตามที่บางสิ่งจะปิดกั้น ฟังดูดี. ปัญหาคือเราท้ายการแก้ไขความซับซ้อนด้วยความซับซ้อนมากขึ้น swapcontext () และตระกูลค่อนข้างแคบไปข้างหน้าความซับซ้อนมาจากที่อื่น ๆ ทันใดนั้นคุณถูกบังคับให้เขียนตารางเวลา userspace และเดาว่ามันยากจริงๆที่จะเขียนตัวจัดตารางเวลาที่จะทำงานได้ดีขึ้นซึ่งตารางเวลาของ Linux ที่มีความพยายามมาหลายปี ตอนนี้คุณต้องการกำหนดเวลาให้กับเธรด N สีเขียวของฟิสิคัลเธรด M ดังนั้นคุณต้องกังวลเกี่ยวกับการซิงโครไนซ์ การซิงโครไนซ์นำปัญหาด้านประสิทธิภาพมาใช้เพื่อให้คุณเริ่มได้ในตอนนี้คุณกำลังลงสู่หลุมกระต่ายที่ไม่มีล็อค การสร้างตัวกำหนดตารางเวลาพร้อมกันที่ถูกต้องสูงไม่ใช่เรื่องง่าย บทวิจารณ์อื่นอยู่ที่นี่ : กระบวนการเดียวที่แกล้งทำหลายเธรดมีปัญหามากมาย หนึ่งในนั้นคือเธรดที่แกล้งทำอยู่บนหน้าเพจที่ผิด คำถามของฉัน - จะไป lang ของ goroutines (สำหรับสระว่ายน้ำเริ่มต้น) เพียงหัวข้อสีเขียว? ถ้าเป็นเช่นนั้นพวกเขาจะจัดการกับคำวิจารณ์ข้างต้นหรือไม่

47 concurrency  go  multithreading 

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

40 programming-languages  concurrency  high-level  modern 

ฉันได้พัฒนาระบบที่เกิดขึ้นพร้อมกันมาหลายปีแล้วและฉันก็เข้าใจดีในเรื่องนี้แม้จะขาดการฝึกอบรมอย่างเป็นทางการ (เช่นไม่มีระดับ) มีภาษาใหม่ไม่กี่ภาษาที่ได้รับความนิยมอย่างน้อยพูดถึงเมื่อเร็ว ๆ นี้ซึ่งได้รับการออกแบบมาเพื่อทำให้การทำงานพร้อมกันง่ายขึ้นเช่น Erlang และ Go ดูเหมือนว่าวิธีการของพวกเขาในการทำงานพร้อมกันนั้นสะท้อนถึงประสบการณ์ของฉันเองว่าจะทำให้ระบบปรับขนาดได้และใช้ประโยชน์จากหลายคอร์ / โปรเซสเซอร์ / เครื่อง อย่างไรก็ตามฉันพบว่ามีเครื่องมือน้อยมากที่จะช่วยให้เห็นภาพสิ่งที่คุณตั้งใจจะทำและยืนยันว่าอย่างน้อยคุณก็ใกล้เคียงกับวิสัยทัศน์ดั้งเดิมของคุณ การดีบักโค้ดที่เกิดขึ้นพร้อมกันอาจเป็นฝันร้ายที่มีภาษาที่ไม่ได้ออกแบบมาสำหรับการทำงานพร้อมกัน (เช่น C / C ++, C #, Java, ฯลฯ ) โดยเฉพาะอย่างยิ่งมันเป็นไปไม่ได้ที่จะสร้างเงื่อนไขที่เกิดขึ้นใหม่ในระบบเดียวในสภาพแวดล้อมการพัฒนาของคุณ ดังนั้นอะไรคือแนวทางของคุณในการออกแบบระบบเพื่อจัดการกับการทำงานพร้อมกันและการประมวลผลแบบขนาน? ตัวอย่าง: คุณคิดได้อย่างไรว่าอะไรจะเกิดขึ้นพร้อมกันกับสิ่งที่ต้องเรียงตามลำดับ? คุณจะสร้างเงื่อนไขข้อผิดพลาดและดูว่าเกิดอะไรขึ้นเมื่อแอปพลิเคชันดำเนินการอย่างไร คุณเห็นภาพปฏิสัมพันธ์ระหว่างส่วนต่าง ๆ ที่เกิดขึ้นพร้อมกันของแอปพลิเคชันอย่างไร ฉันมีคำตอบของตัวเองสำหรับสิ่งเหล่านี้ แต่ฉันก็ต้องการที่จะเรียนรู้เพิ่มเติมอีกเล็กน้อย แก้ไข จนถึงตอนนี้เรามีข้อมูลที่ดีมากมาย บทความหลายบทความที่เชื่อมโยงนั้นดีมากและฉันได้อ่านมาแล้วบางส่วน ประสบการณ์ส่วนตัวของฉันกับการเขียนโปรแกรมพร้อมกันทำให้ฉันเชื่อว่าคุณต้องการความคิดที่แตกต่างจากการเขียนโปรแกรมตามลำดับ ความแตกแยกทางจิตใจนั้นกว้างพอ ๆ กับความแตกต่างระหว่างการเขียนโปรแกรมเชิงวัตถุและการโปรแกรมเชิงกระบวนวิธี ฉันต้องการชุดคำถามนี้เพื่อมุ่งเน้นที่กระบวนการคิดที่จำเป็น (เช่นทฤษฎี) เพื่อเข้าหาคำตอบอย่างเป็นระบบ เมื่อให้คำตอบที่เป็นรูปธรรมมากขึ้นมันจะช่วยยกตัวอย่าง - สิ่งที่คุณต้องผ่านเป็นการส่วนตัว เป้าหมายสำหรับค่าหัว อย่าบอกฉันว่าฉันควรทำอย่างไร …

37 design  debugging  parallelism  concurrency 

ในวันแรก ๆ ของ FORTRAN และ BASIC โปรแกรมทั้งหมดถูกเขียนด้วยคำสั่ง GOTO ผลลัพธ์คือโค้ดสปาเก็ตตี้และวิธีแก้ปัญหาคือการเขียนโปรแกรมแบบมีโครงสร้าง ตัวชี้อาจมีลักษณะควบคุมได้ยากในโปรแกรมของเรา C ++ เริ่มต้นด้วยตัวชี้มากมาย แต่แนะนำให้ใช้การอ้างอิง ไลบรารี่อย่าง STL สามารถลดการพึ่งพาของเราได้บ้าง นอกจากนี้ยังมีสำนวนในการสร้างสมาร์ทพอยน์เตอร์ที่มีคุณสมบัติดีกว่าและ C ++ บางรุ่นจะอนุญาตให้อ้างอิงและจัดการโค้ด วิธีปฏิบัติในการเขียนโปรแกรมเช่นการสืบทอดและ polymorphism ใช้ตัวชี้จำนวนมากเบื้องหลัง ภาษาเช่น Java กำจัดพอยน์เตอร์และใช้การรวบรวมขยะเพื่อจัดการข้อมูลที่จัดสรรแบบไดนามิกแทนที่จะขึ้นอยู่กับโปรแกรมเมอร์เพื่อจับคู่คำสั่งใหม่และลบทั้งหมด ในการอ่านของฉันฉันได้เห็นตัวอย่างของการเขียนโปรแกรมแบบหลายกระบวนการและหลายเธรดที่ดูเหมือนจะไม่ใช้เซมาฟอร์ พวกเขาใช้สิ่งเดียวกันกับชื่อที่แตกต่างกันหรือพวกเขามีวิธีการใหม่ในการจัดโครงสร้างการปกป้องทรัพยากรจากการใช้งานพร้อมกันหรือไม่? ตัวอย่างเช่นตัวอย่างเฉพาะของระบบสำหรับการเขียนโปรแกรมมัลติเธรดที่มีตัวประมวลผลมัลติคอร์คือ OpenMP มันแสดงให้เห็นถึงภูมิภาคที่สำคัญดังต่อไปนี้โดยไม่ต้องใช้เซมาฟอร์ซึ่งดูเหมือนจะไม่รวมอยู่ในสภาพแวดล้อม th_id = omp_get_thread_num(); #pragma omp critical { cout << "Hello World from thread " << th_id << '\n'; …

36 coding-standards  multithreading  concurrency  multi-core 

คำถาม ฉันพยายามที่จะเข้าใจว่าสนิมช่วยปรับปรุงพื้นฐานและพร้อมกันของสิ่งอำนวยความสะดวกในการทำงานพร้อมกันของ C ++ หรือไม่เพื่อที่จะตัดสินใจว่าฉันควรใช้เวลาในการเรียนรู้สนิมหรือไม่ โดยเฉพาะอย่างยิ่ง idiomatic Rust จะพัฒนาขึ้นอย่างไรหรือในอัตราที่ต่างกันอย่างไรสิ่งอำนวยความสะดวกที่เกิดขึ้นพร้อมกันของ C ++ การปรับปรุง (หรือความแตกต่าง) ส่วนใหญ่เกี่ยวกับการสร้างประโยคหรือเป็นการปรับปรุงที่สำคัญในกระบวนทัศน์หรือไม่? หรือมันเป็นอย่างอื่น? หรือไม่เป็นการปรับปรุงที่แท้จริง (divergence) เลยเหรอ? หลักการและเหตุผล ฉันเพิ่งพยายามสอนสิ่งอำนวยความสะดวกในการทำงานพร้อมกันของ C ++ 14 และมีบางสิ่งที่รู้สึกไม่ถูกต้อง บางสิ่งบางอย่างรู้สึกปิด สิ่งที่รู้สึกออก? ยากที่จะพูด. รู้สึกว่าคอมไพเลอร์ไม่ได้พยายามช่วยฉันในการเขียนโปรแกรมที่ถูกต้องเมื่อพูดถึงการทำงานพร้อมกัน รู้สึกราวกับว่าฉันกำลังใช้แอสเซมเบลอร์มากกว่าคอมไพเลอร์ เป็นที่ยอมรับกันว่าเป็นไปได้ทั้งหมดที่ฉันยังต้องทนทุกข์ทรมานจากแนวคิดที่บอบบางและผิดพลาดเมื่อมันเกิดขึ้นพร้อมกัน บางทีฉันอาจจะยังไม่เห็นความตึงเครียดของ Bartosz Milewski ระหว่างการเขียนโปรแกรมแบบรัฐและการแข่งขันข้อมูล บางทีฉันอาจไม่เข้าใจว่ามีวิธีการทำงานพร้อมกันของเสียงในคอมไพเลอร์มากน้อยแค่ไหนและมันมีอยู่ในระบบปฏิบัติการเท่าใด

35 c++  concurrency  rust  c++14 

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

34 concurrency 

ในขณะที่ฉันรู้ว่าคำถามนี้ได้รับการครอบคลุมแล้ว (เช่นhttps://stackoverflow.com/questions/5713142/green-threads-vs-non-green-threads ) ฉันไม่รู้สึกว่าฉันได้รับคำตอบที่น่าพอใจ . คำถามคือ: ทำไม JVM ไม่สนับสนุนเธรดสีเขียวอีกต่อไป? มันบอกว่านี้ในแบบโค้ด Java คำถามที่พบบ่อย : เธรดสีเขียวหมายถึงโหมดการทำงานของ Java Virtual Machine (JVM) ซึ่งโค้ดทั้งหมดจะถูกดำเนินการในเธรดระบบปฏิบัติการเดียว และสิ่งนี้จบบนjava.sun.com : ข้อเสียคือการใช้เธรดสีเขียวหมายถึงเธรดระบบบน Linux ไม่ได้รับประโยชน์และดังนั้นเครื่องเสมือน Java จึงไม่สามารถปรับขนาดได้เมื่อเพิ่มซีพียูเพิ่มเติม สำหรับฉันแล้วดูเหมือนว่า JVM อาจมีกระบวนการของระบบเท่ากับจำนวนแกนประมวลผลจากนั้นจึงรันเธรดสีเขียวที่ด้านบนของนั้น สิ่งนี้อาจมีข้อได้เปรียบที่ยิ่งใหญ่เมื่อคุณมีเธรดจำนวนมากซึ่งบล็อกบ่อยครั้ง (ส่วนใหญ่เป็นเพราะจำนวนสูงสุดของเธรด JVM ในปัจจุบัน) คิด?

33 java  multithreading  concurrency 

ฉันมี 10K LOCโครงการเขียนในDjangoค่อนข้างจัดการของคื่นฉ่าย ( RabbitMQ ) สำหรับ asynchronicity และพื้นหลังงานที่จำเป็นและได้มาสรุปว่าบางส่วนของระบบที่จะได้รับประโยชน์จากการถูกเขียนใหม่ในบางสิ่งบางอย่างอื่นนอกเหนือจาก Django สำหรับการทำงานพร้อมกันดีกว่า . เหตุผลรวมถึง: การจัดการสัญญาณและวัตถุที่ไม่แน่นอน โดยเฉพาะอย่างยิ่งเมื่อสัญญาณหนึ่งเรียกอีกอย่างหนึ่งการจัดการสัญญาณใน Django โดยใช้ORMนั้นน่าประหลาดใจเมื่อมีการเปลี่ยนแปลงหรือหายไป ฉันต้องการใช้วิธีการส่งข้อความบางอย่างที่ข้อมูลที่ส่งผ่านไปไม่เปลี่ยนแปลงในตัวจัดการ (วิธีการคัดลอกเมื่อเขียนของ Clojureดูดีถ้าฉันทำถูก) บางส่วนของระบบไม่ได้อยู่บนเว็บและต้องการการสนับสนุนที่ดีกว่าสำหรับการปฏิบัติงานพร้อมกัน ตัวอย่างเช่นระบบอ่านแท็กNFCและเมื่อมีการอ่าน LED จะทำงานต่อไปอีกสองสามวินาที (งาน Celery) เสียงเล่น (งาน Celery อื่น ๆ ) และมีการสอบถามฐานข้อมูล (งานอื่น ๆ ) สิ่งนี้ถูกนำไปใช้เป็นคำสั่งการจัดการ Django แต่ Django และ ORM ของมันถูกซิงโครไนซ์โดยธรรมชาติและการแชร์หน่วยความจำนั้นมี จำกัด (เรากำลังคิดที่จะเพิ่มเครื่องอ่าน NFC มากขึ้นและฉันไม่คิดว่าวิธี Django + Celery …

31 python  concurrency 

ฉันเป็นผู้พัฒนารุ่นน้องที่กำลังทำงานเกี่ยวกับการเขียนอัปเดตสำหรับซอฟต์แวร์ที่รับข้อมูลจากโซลูชันของบุคคลที่สามจัดเก็บไว้ในฐานข้อมูลจากนั้นกำหนดเงื่อนไขข้อมูลสำหรับการใช้งานโดยโซลูชันของ บริษัท อื่น ซอฟต์แวร์ของเราทำงานเป็นบริการ Windows ดูรหัสจากรุ่นก่อนหน้าฉันเห็นสิ่งนี้: static Object _workerLocker = new object(); static int _runningWorkers = 0; int MaxSimultaneousThreads = 5; foreach(int SomeObject in ListOfObjects) { lock (_workerLocker) { while (_runningWorkers >= MaxSimultaneousThreads) { Monitor.Wait(_workerLocker); } } // check to see if the service has been stopped. If yes, then …

27 c#  .net  concurrency  locks 

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

25 architecture  uml  multithreading  concurrency