क्या डेडलॉकिंग को रोकने के दौरान जंग में एकाधिक म्यूटेक्स लॉक करने की सुविधा है?

Question

वहाँ एक सी ++ std::lock() जंग में सुविधा की तरह इस तरह कोड में deadlocking को रोकने के लिए है:

type Type0 = Arc<Mutex<u8>>; 
type Type1 = Arc<Mutex<u16>>; 

fn foo(a: Type0, b: Type1) { 
    let a_guard = a.lock().unwrap(); 
    let b_guard = b.lock().unwrap(); 
} 

fn bar(a: Type0, b: Type1) { 
    let b_guard = b.lock().unwrap(); 
    let a_guard = a.lock().unwrap(); 
} 

तो foo वहाँ गतिरोध का एक मौका है धागा 0 और bar से पुकारा जाता है धागा -1 द्वारा। क्या कुछ ऐसा है, उम्मीद है कि अलग-अलग है क्योंकि मेरे पास 2 से अधिक हो सकते हैं, इस के साथ मेरी मदद करने के लिए या क्या मैं लॉकिंग के आदेश की शुद्धता की पुष्टि कर रहा हूं?

the documentation for std::lock से:

एक गतिरोध परिहार एल्गोरिथ्म का उपयोग कर गतिरोध से बचने के लिए दिए गए Lockable वस्तुओं lock1, lock2, ..., lockn लॉक करता है।

Answer 1

नहीं, जंग नहीं है (या अभी तक नहीं है) एक समारोह बराबर करने के लिए है सी ++ के std::lock।

इस तथ्य के आधार पर कि यह std::sync documentation में प्रतीत नहीं होता है और गूगलिंग कुछ भी उपयोगी नहीं लाता है, मुझे इस दावे में बहुत भरोसा है।

क्यों नहीं? खैर, अगर मैं थोड़ी सी संपादकीयता कर सकता हूं, std::lock यह बहुत अच्छा विचार नहीं है - डेडलॉक टावर नॉनट्रिविअल है और प्रत्येक एल्गोरिदम में व्यावहारिक कोने के मामले होंगे जिसके परिणामस्वरूप खराब प्रदर्शन या यहां तक ​​कि आजीविका भी होगी। कोई भी आकार-फिट नहीं है-सभी डेडलॉक टावरेंस एल्गोरिदम।

(आप Vec::sort जैसे अन्य कार्यों के लिए एक ही तर्क कर सकते हैं, लेकिन मुझे लगता है कि कई अनुप्रयोगों में "सॉर्टिंग" की आवश्यकता है जहां प्रदर्शन महत्वपूर्ण नहीं है, और किसी भी उचित प्रकार के एल्गोरिदम के लिए पर्याप्त प्रदर्शन किया जाएगा> आवेदनों की 75%। डेडलॉक परिहार, ज्यादातर आवश्यक केवल जब आप पहले से ही कोड में अच्छा प्रदर्शन करने की जरूरत है कि लिख रहे है।)

इसके अलावा मानक पुस्तकालय में एक गतिरोध-परहेज lock समारोह डाल पता चलता है कि यह एक अच्छा डिफ़ॉल्ट पसंद है , और इसके कार्यान्वयन के संबंध में इसके उपयोग को प्रोत्साहित करता है। हकीकत में, अधिकतर अनुप्रयोग शायद एक सरल (और कम सामान्य उद्देश्य) एल्गोरिदम के साथ बेहतर प्रदर्शन करेंगे।

वैसे भी, इस समस्या को हल करने के लिए आपको कुछ भी "बैकिंग ऑफ" एल्गोरिदम लिखने से रोकता है; यह सिर्फ मानक पुस्तकालय का हिस्सा नहीं है।

Answer 2

यह आसानी से सुलझाया जाता है यदि Mutex निहित मानों के साथ एक टुपल है, ताकि ट्यूपल लॉकिंग दोनों मूल्यों को एक साथ लॉक कर दे।

let tuple_mutex = Arc::new(Mutex::new((A, B)));