इंटरमाचिन लॉकिंग करने के कुछ अच्छे तरीके क्या हैं?

Question

हमारे सर्वर क्लस्टर में 20 मशीनें हैं, प्रत्येक में 5 धागे के 10 पिड्स हैं। हम किसी भी मशीन पर, किसी भी मशीन पर किसी भी दो थ्रेड को किसी भी मशीन पर एक ही ऑब्जेक्ट को संशोधित करने से रोकने के लिए कुछ तरीका चाहते हैं।

हमारा कोड पायथन में लिखा गया है और लिनक्स पर चलता है, अगर इससे संकीर्ण चीजों को कम करने में मदद मिलती है।

इसके अलावा, यह एक बहुत ही दुर्लभ मामला है कि दो ऐसे धागे ऐसा करना चाहते हैं, इसलिए हम कुछ ऐसा पसंद करेंगे जो "केवल एक थ्रेड को इस ऑब्जेक्ट की आवश्यकता है" केस को वास्तव में तेज़ करने के लिए अनुकूलित करता है, भले ही इसका मतलब है कि " एक धागे ने इस वस्तु को बंद कर दिया है और किसी और को इसकी जरूरत है "मामला बहुत अच्छा नहीं है।

कुछ सर्वोत्तम प्रथाएं क्या हैं?

Answer 1

आप समन्वयन के लिए मशीनों के लिए आप एक Distributed Lock Manager जरूरत चाहते हैं नहीं है।

मैंने कुछ त्वरित googling किया और साथ आया: Stackoverflow। दुर्भाग्य से वे केवल जावा संस्करण का सुझाव देते हैं, लेकिन यह एक शुरुआत है।

यदि आप फ़ाइलों तक पहुंच को सिंक्रनाइज़ करने का प्रयास कर रहे हैं: आपके फाइल सिस्टम में पहले से ही लॉकिंग सेवा का कुछ wort होना चाहिए। अगर इसे बदलने पर विचार न करें।

Answer 2

ऐसा करने के लिए एक बेहतर तरीका हो सकता है, लेकिन मैं "संरक्षित" वस्तुओं, यहाँ बयान के साथ एक में उपयोग करने के लिए सूत्रण मॉड्यूल से लॉक वर्ग का प्रयोग करेंगे एक उदाहरण होगा:

from __future__ import with_statement  
from threading import Lock 

mylock = Lock() 
with mylock.acquire(): 
    [ 'do things with protected data here' ] 
[ 'the rest of the code' ] 

लॉक उपयोग के बारे में अधिक उदाहरणों के लिए, देखें।

संपादित करें: इस समाधान threading.Lock के रूप में इस प्रश्न के लिए उपयुक्त वितरित नहीं है, खेद

Answer 3

मुझे लगता है कि आप इस ब्लॉग पोस्ट http://amix.dk/blog/post/19386 पर अपने गुगल के दौरान आए थे?

लेखक memcachedb को एक साधारण इंटरफेस प्रदर्शित करता है जो इसे डमी वितरित लॉक मैनेजर के रूप में उपयोग करता है। यह एक अच्छा विचार है, और memcache शायद तेज़ चीज में से एक है जिसके साथ आप इंटरफेस करने में सक्षम होंगे। ध्यान दें कि यह हाल ही में कथन के साथ जोड़ा गया है।

from __future__ import with_statement 
import memcache 
from memcached_lock import dist_lock 

client = memcache.Client(['127.0.0.1:11211']) 
with dist_lock('test', client): 
    print 'Is there anybody out there!?' 

Answer 4

लिखें अपरिवर्तनीय वस्तुओं का उपयोग कर कोड:

यहाँ अपने ब्लॉग पोस्ट से एक उदाहरण के उपयोग है। सिंगलटन पैटर्न को लागू करने वाली वस्तुओं को लिखें।

एक स्थिर वितरित संदेश तकनीक जैसे आईपीसी, वेब सर्विसेज, या एक्सएमएल-आरपीसी का उपयोग करें।

मैं ट्विस्ट पर एक नज़र डालेगा। उन्हें इस तरह के कार्य के लिए बहुत सारे समाधान मिल गए।

मैं जीआईएल के संबंध में पाइथन एएसपी में धागे का उपयोग नहीं करता, मैं प्रक्रियाओं के रूप में प्रक्रियाओं का उपयोग करने और इंटरकेशनल के लिए ऊपर वर्णित कॉमम्स तकनीक का उपयोग करने के लिए देखता हूं।

आपकी सिंगलटन कक्षा तब इन अनुप्रयोगों में से एक में दिखाई दे सकती है और पसंद के कॉमम्स प्रौद्योगिकी के माध्यम से इंटरफेस की जा सकती है।

सभी इंटरफेसिंग के साथ एक तेज़ समाधान नहीं है, लेकिन यदि सही तरीके से किया जाना चाहिए तो स्थिर होना चाहिए।

Answer 5

यदि आप एक वितरित लॉक प्रबंधक के लिए पूर्ण आधारभूत संरचना प्राप्त कर सकते हैं तो आगे बढ़ें और इसका उपयोग करें। लेकिन उस बुनियादी ढांचे को स्थापित करना आसान नहीं है! लेकिन यहां एक व्यावहारिक समाधान है:

- मास्टर नोड के रूप में निम्नतम आईपी पते के साथ नोड को डिज़ाइन करें (इसका मतलब है कि यदि निम्नतम आईपी पते वाला नोड लटकता है, तो सबसे कम आईपी पता वाला नया नोड नया मास्टर बन जाएगा)

-ऑब्जेक्ट पर लॉक प्राप्त करने के लिए सभी नोड्स मास्टर नोड से संपर्क करें।

- मास्टर नोड लॉक प्राप्त करने के लिए देशी लॉक अर्थशास्त्र का उपयोग करें।

इससे चीजों को सरल बना दिया जाएगा जब तक कि आपको नौकरी करने के लिए पूर्ण क्लस्टरिंग इंफ्रास्ट्रक्चर और डीएलएम की आवश्यकता न हो।