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

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

4
ฉันควรทำอย่างไรเมื่อการล็อคในแง่ดีไม่ทำงาน
ฉันมีสถานการณ์ต่อไปนี้: ผู้ใช้ทำให้GETคำขอไป/projects/1และได้รับการETag ผู้ใช้ทำการร้องขอPUT/projects/1กับ ETag จากขั้นตอน # 1 ผู้ใช้ทำการร้องขอ PUT อื่น/projects/1โดยใช้ ETag จากขั้นตอนที่ # 1 โดยปกติคำขอ PUT ที่สองจะได้รับการตอบสนอง 412 เนื่องจาก ETag ตอนนี้ค้าง - คำขอ PUT แรกแก้ไขทรัพยากรดังนั้น ETag จึงไม่ตรงกันอีกต่อไป แต่จะเกิดอะไรขึ้นถ้าคำขอ PUT ทั้งสองนั้นถูกส่งในเวลาเดียวกัน คำขอ PUT แรกไม่มีเวลาในการประมวลผลและอัปเดตทรัพยากรก่อน PUT # 2 มาถึงซึ่งทำให้ PUT # 2 เขียนทับ PUT # 1 จุดรวมของการล็อคในแง่ดีคือการที่จะไม่เกิดขึ้น ...

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

1
แนวคิดมันหมายความว่าอย่างไรเมื่อมีการกล่าวว่าแต่ละเธรดได้รับสแต็กของตัวเอง?
ฉันได้อ่านJava Concurrency ในทางปฏิบัติโดย Brian Goetz และในส่วนStack Confinementมีการกล่าวถึงว่าแต่ละเธรดได้รับสแต็กของตัวเองและตัวแปรในเครื่องจึง จำกัด อยู่ภายในเธรดที่กำลังดำเนินการ มีอยู่ในเธรดที่กำลังเรียกใช้งานซึ่งไม่สามารถเข้าถึงได้กับเธรดอื่น เขาหมายความว่าอะไรที่แต่ละเธรดมีสแตกการเรียกใช้ของตนเอง

3
กำลังมองหารูปแบบการล็อคแบบกระจาย
ฉันจำเป็นต้องมีกลไกการล็อคออบเจ็กต์ซ้ำแบบกำหนดเอง \ pattern สำหรับระบบแบบกระจายใน C # โดยพื้นฐานแล้วฉันมีระบบหลายโหนด แต่ละโหนดมีสิทธิ์การเขียนพิเศษเหนือชิ้นส่วนของn -number สถานะเดียวกันนี้ยังมีอยู่ในรูปแบบอ่านอย่างเดียวบนโหนดอื่นอย่างน้อยหนึ่งโหนด การเขียน / อัปเดตบางรายการจะต้องเป็นแบบปรมาณูในทุกโหนดในขณะที่การอัปเดตอื่น ๆ ในที่สุดจะกลายเป็นกระบวนการจำลองแบบพื้นหลังที่สอดคล้องกันคิว ฯลฯ ... สำหรับการอัปเดตอะตอมมิกฉันกำลังมองหารูปแบบหรือตัวอย่างที่อนุญาตให้ฉันทำเครื่องหมายวัตถุอย่างถูกล็อกสำหรับการเขียนซึ่งฉันสามารถกระจายกระทำย้อนกลับ ฯลฯ ... เนื่องจากระบบมีการทำงานพร้อมกันในระดับสูงฉัน ฉันคิดว่าฉันจะต้องสามารถล็อคสแต็กอัพซึ่งจะหมดเวลาหรือไม่ได้เปิดเมื่อล็อคถูกปล่อยออกมา ส่วนการทำธุรกรรมหรือการส่งข้อความนั้นไม่ได้เป็นจุดสนใจของคำถามนี้ แต่ฉันได้จัดเตรียมไว้สำหรับบริบทเพิ่มเติมบางอย่าง จากที่กล่าวมาคุณสามารถพูดได้อย่างชัดเจนว่าคุณต้องการข้อความใดหากคุณต้องการ นี่คือตัวอย่างที่คลุมเครือของสิ่งที่ฉันคาดคิดแม้ว่าฉันจะเปิดรับความคิดใหม่ ๆ นอกเหนือจากการใช้ผลิตภัณฑ์ใหม่ทั้งหมด thing.AquireLock(LockLevel.Write); //Do work thing.ReleaseLock(); ฉันคิดว่าจะใช้วิธีการขยายซึ่งอาจมีลักษณะเช่นนี้ public static void AquireLock(this IThing instance, TupleLockLevel lockLevel) { //TODO: Add aquisition wait, retry, recursion count, timeout …

1
เมื่องานอะซิงโครนัสทำให้ UX ไม่ดี
ฉันกำลังเขียน COM add-in ที่ขยาย IDE ที่ต้องการอย่างยิ่ง มีคุณสมบัติหลายอย่างที่เกี่ยวข้อง แต่ให้แคบลงเป็น 2 เพื่อประโยชน์ของโพสต์นี้: มีเครื่องมือExplorer ในหน้าต่างที่แสดงมุมมองแบบต้นไม้ที่ช่วยให้ผู้ใช้นำทางโมดูลและสมาชิกของพวกเขา มีเครื่องมือตรวจสอบรหัสหน้าต่างที่แสดงDataGridviewที่ให้ผู้ใช้สำรวจปัญหารหัสและแก้ไขให้โดยอัตโนมัติ เครื่องมือทั้งสองมีปุ่ม "รีเฟรช" ที่เริ่มงานแบบอะซิงโครนัสที่แยกวิเคราะห์รหัสทั้งหมดในโครงการที่เปิดอยู่ทั้งหมด รหัส Explorer ที่ใช้ผลการแจงการสร้างTreeViewและรหัสการตรวจสอบการใช้ผลการแจงที่จะพบปัญหารหัสและแสดงผลลัพธ์ในของDataGridView สิ่งที่ฉันพยายามที่จะทำที่นี่คือการแบ่งปันผลแยกระหว่างคุณสมบัติเพื่อที่ว่าเมื่อรหัส Explorer ในการรีเฟรชแล้วรหัสการตรวจสอบรู้เกี่ยวกับมันและสามารถฟื้นฟูตัวเองได้โดยไม่ต้องทำซ้ำการทำงานแยกว่ารหัส Explorer ที่ก็ไม่ได้ . ดังนั้นสิ่งที่ฉันทำฉันทำให้ parser class เป็นผู้ให้บริการเหตุการณ์ที่คุณสมบัติสามารถลงทะเบียนได้ที่: private void _parser_ParseCompleted(object sender, ParseCompletedEventArgs e) { Control.Invoke((MethodInvoker) delegate { Control.SolutionTree.Nodes.Clear(); foreach (var result in e.ParseResults) { var node = new …

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

2
ทำไม Akka ถึงดีสำหรับการเกิดพร้อมกัน?
ฉันยังใหม่กับกรอบของอัคคาและนักแสดง - ฉันแน่ใจว่าฉันขาดอะไรที่ชัดเจนโปรดยอมรับคำขอโทษล่วงหน้า ฉันอ่านต่อไปว่าหนึ่งในประเด็นหลักในการเลือก Akka คือวิธีที่มันจัดการการทำงานพร้อมกัน ไม่ชัดเจนสำหรับฉันว่าทำไม Akka ถึงมีความพิเศษ ฉันเข้าใจว่ามีนักแสดงน้อยมากที่เบาและเร็วมาก อย่างไรก็ตามสิ่งนี้จะช่วยฉันได้อย่างไรเมื่อผู้ใช้สองคนบันทึกฟอร์มในเวลาเดียวกัน ฉันจะยังคงต้องล็อคการทำงานพร้อมกันบางอย่าง (มองโลกในแง่ร้าย / แง่ดี / ฯลฯ .. )?

3
REST จำกัด เฉพาะการควบคุมภาวะพร้อมกันในแง่ดีหรือไม่?
บริบท เนื่องจากความไร้สัญชาติของรูปแบบสถาปัตยกรรม REST ที่เกี่ยวข้องกับการร้องขอแต่ละรายการนั้นล้วน แต่อยู่คนเดียวเซิร์ฟเวอร์ชั้นนำที่จะไม่เก็บข้อมูลใด ๆ เกี่ยวกับลูกค้า ดังนั้นการควบคุมภาวะพร้อมกันในแง่ร้ายไม่เหมาะสมเพราะจะต้องมีการจัดเก็บเซิร์ฟเวอร์ที่ลูกค้าจะได้รับการล็อคทรัพยากร การควบคุมภาวะพร้อมกันในแง่ดีนั้นจะถูกนำมาใช้ด้วยความช่วยเหลือของEtagส่วนหัว (btw ตามที่ฉันถาม/programming/30080634/concurrency-in-a-rest-api ) ปัญหา ปัญหาหลักที่เกิดขึ้นกับกลไกการควบคุมภาวะพร้อมกันในแง่ดีคือคุณอนุญาตให้ลูกค้าทุกคนทำการดำเนินการใด ๆ ได้ตลอดเวลา และฉันต้องการหลีกเลี่ยงสิ่งนั้นโดยไม่ทำลายหลักการไร้สัญชาติของ REST ฉันหมายความว่าลูกค้าทั้งหมดไม่สามารถดำเนินการใด ๆ ได้ตลอดเวลา คำถาม ในใจของฉันมันเป็นไปได้ด้วยกลไกการควบคุมภาวะพร้อมกันแบบกึ่งมองโลกในแง่ดีเช่นนั้น: ลูกค้าสามารถขอโทเค็น สามารถสร้างโทเค็นเดียวเท่านั้นและมีระยะเวลาที่ จำกัด หากต้องการดำเนินการกับทรัพยากร (เช่นPOSTหรือPUT ) ไคลเอ็นต์จะต้องให้โทเค็นนี้เป็นส่วนหนึ่งของเนื้อความ (หรือส่วนหัว?) ของคำขอ ลูกค้าที่ไม่มีโทเค็นไม่สามารถทำการดำเนินการเหล่านี้ได้ มันคล้ายกันมากกับการควบคุมภาวะพร้อมกันในแง่ดียกเว้นว่ามีลูกค้าเพียงรายเดียวเท่านั้นที่สามารถทำการดำเนินการบางอย่าง (ลูกค้าที่ได้รับโทเค็น) ... ตรงข้ามกับ "ลูกค้าทุกคนสามารถดำเนินการทั้งหมดได้" กลไกนี้เข้ากันได้กับสไตล์สถาปัตยกรรม REST หรือไม่? มันทำลายข้อ จำกัด ใด ๆ หรือไม่? ฉันคิดว่าจะถาม SO แต่ดูเหมือนว่าจะเป็นคำถามระดับสูงที่เกี่ยวข้องกับการออกแบบซอฟต์แวร์

3
ทรัพยากรที่แนะนำสำหรับการเรียนรู้เกี่ยวกับรูปแบบของนักแสดงของระบบเกิดขึ้นพร้อมกันคืออะไร [ปิด]
ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน6 ปีที่ผ่านมา โมเดลการทำงานพร้อมกันของนักแสดงนั้นได้รับความนิยมอย่างชัดเจน มีหนังสือที่ดีที่แสดงรูปแบบและข้อผิดพลาดของแบบจำลองหรือไม่? ฉันกำลังคิดถึงบางสิ่งที่จะพูดถึงตัวอย่างเช่นปัญหาความมั่นคงและความถูกต้องในบริบทของนักแสดงอิสระนับร้อยหรือพันคน มันคงจะโอเคถ้ามันเกี่ยวข้องกับภาษาที่เฉพาะเจาะจง (Erlang ฉันจะจินตนาการเพราะนั่นดูเหมือนจะได้รับการยอมรับอย่างกว้างขวางว่าเป็นการนำไปปฏิบัติที่พิสูจน์แล้วของนักแสดง) แต่ฉันหวังว่าจะมีอะไรมากกว่าบทแนะนำหรือสองบท จริง ๆ แล้วฉันสนใจนักแสดงมากที่สุดเนื่องจากพวกเขานำไปใช้งานใน Scala หากมีทรัพยากรดังกล่าว

6
ถัดไปในการทำงานพร้อมกัน
สำหรับปีที่ผ่านมาฉันทำงานหลายอย่างเกี่ยวกับการทำงานพร้อมกันใน Java และมีการสร้างและทำงานบนแพคเกจพร้อมกันจำนวนมาก ดังนั้นในแง่ของการพัฒนาในโลกที่เกิดขึ้นพร้อมกันฉันค่อนข้างมั่นใจ ต่อไปฉันสนใจที่จะเรียนรู้และทำความเข้าใจเพิ่มเติมเกี่ยวกับการเขียนโปรแกรมพร้อมกัน แต่ฉันไม่สามารถตอบตัวเองในสิ่งต่อไปได้ ฉันควรเรียนรู้อะไรเพิ่มเติมหรือทำงานเพื่อเพิ่มพูนทักษะที่เกี่ยวข้องกับการประมวลผลแบบมัลติคอร์ หากมีหนังสือดีๆ (อ่านและสนุกกับ 'การทำงานพร้อมกันในทางปฏิบัติ' และ 'การเขียนโปรแกรมพร้อมกันใน java') หรือทรัพยากรที่เกี่ยวข้องกับการประมวลผลแบบมัลติคอร์เพื่อให้ฉันสามารถไปยังระดับถัดไปได้หรือไม่
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.