मुझे पायथन में लिखने के लिए एक फ़ाइल लॉक करने की आवश्यकता है। इसे एक बार में कई पायथन प्रक्रियाओं से एक्सेस किया जाएगा। मुझे कुछ समाधान ऑनलाइन मिले हैं, लेकिन मेरे उद्देश्यों के लिए सबसे असफल हैं क्योंकि वे अक्सर केवल यूनिक्स आधारित या विंडोज आधारित हैं।
जवाबों:
ठीक है, इसलिए मैंने अपने द्वारा लिखे गए कोड के साथ जाना समाप्त कर दिया, मेरी वेबसाइट पर लिंक मर चुका है, संग्रह.org पर देखें ( गीथहब पर भी उपलब्ध है )। मैं निम्नलिखित फैशन में इसका उपयोग कर सकता हूं:
from filelock import FileLock
with FileLock("myfile.txt.lock"):
print("Lock acquired.")
with open("myfile.txt"):
# work with the file as it is now lockedयहाँ एक क्रॉस-प्लेटफ़ॉर्म फ़ाइल लॉकिंग मॉड्यूल है: Portalocker
यद्यपि केविन कहते हैं, एक बार में कई प्रक्रियाओं से किसी फ़ाइल पर लिखना कुछ ऐसा है जिससे आप बचना चाहते हैं।
यदि आप अपनी समस्या को एक डेटाबेस में शामिल कर सकते हैं, तो आप SQLite का उपयोग कर सकते हैं। यह समवर्ती पहुंच का समर्थन करता है और अपनी लॉकिंग को संभालता है।
अन्य समाधान बहुत सारे बाह्य कोड आधारों का हवाला देते हैं। यदि आप इसे स्वयं करना पसंद करेंगे, तो यहां क्रॉस-प्लेटफ़ॉर्म समाधान के लिए कुछ कोड दिए गए हैं जो लिनक्स / एनओएस सिस्टम पर संबंधित फ़ाइल लॉकिंग टूल का उपयोग करते हैं।
try:
# Posix based file locking (Linux, Ubuntu, MacOS, etc.)
import fcntl, os
def lock_file(f):
fcntl.lockf(f, fcntl.LOCK_EX)
def unlock_file(f):
fcntl.lockf(f, fcntl.LOCK_UN)
except ModuleNotFoundError:
# Windows file locking
import msvcrt, os
def file_size(f):
return os.path.getsize( os.path.realpath(f.name) )
def lock_file(f):
msvcrt.locking(f.fileno(), msvcrt.LK_RLCK, file_size(f))
def unlock_file(f):
msvcrt.locking(f.fileno(), msvcrt.LK_UNLCK, file_size(f))
# Class for ensuring that all file operations are atomic, treat
# initialization like a standard call to 'open' that happens to be atomic.
# This file opener *must* be used in a "with" block.
class AtomicOpen:
# Open the file with arguments provided by user. Then acquire
# a lock on that file object (WARNING: Advisory locking).
def __init__(self, path, *args, **kwargs):
# Open the file and acquire a lock on the file before operating
self.file = open(path,*args, **kwargs)
# Lock the opened file
lock_file(self.file)
# Return the opened file object (knowing a lock has been obtained).
def __enter__(self, *args, **kwargs): return self.file
# Unlock the file and close the file object.
def __exit__(self, exc_type=None, exc_value=None, traceback=None):
# Flush to make sure all buffered contents are written to file.
self.file.flush()
os.fsync(self.file.fileno())
# Release the lock on the file.
unlock_file(self.file)
self.file.close()
# Handle exceptions that may have come up during execution, by
# default any exceptions are raised to the user.
if (exc_type != None): return False
else: return True अब, AtomicOpenएक withब्लॉक में इस्तेमाल किया जा सकता है जहां कोई सामान्य रूप से एक openबयान का उपयोग करेगा ।
चेतावनी: यदि निकास से पहले विंडोज और पायथन क्रैश पर चल रहा है, तो मुझे यकीन नहीं है कि लॉक व्यवहार क्या होगा।
चेतावनी: यहां दी गई लॉकिंग सलाहकार है, निरपेक्ष नहीं। सभी संभावित प्रतिस्पर्धी प्रक्रियाओं को "एटॉमिकऑपेन" वर्ग का उपयोग करना चाहिए।
unlock_fileलिनक्स पर फाइल को झंडे के fcntlसाथ फिर से कॉल नहीं करना चाहिए LOCK_UN?
__exit__आप closeबाहर के बाद लॉक की unlock_file। मेरा मानना है कि रनटाइम के दौरान डेटा फ्लश (यानी, लिख) सकता है close। मेरा मानना है कि किसी भी अतिरिक्त डेटा के दौरान लॉक के बाहर नहीं लिखा है यह सुनिश्चित करने के लिए एक flushऔर fsyncलॉक के नीचे होना चाहिए close।
flushऔर fsync। मैंने कॉल करने से पहले आपके द्वारा सुझाई गई दो पंक्तियों को जोड़ दिया है unlock। मैंने फिर से परीक्षण किया और दौड़ की स्थिति हल होती दिखाई दे रही है।
मैं लॉकफाइल पसंद करता हूं - प्लेटफ़ॉर्म-स्वतंत्र फ़ाइल लॉकिंग
मैं ऐसा करने के लिए कई समाधानों को देख रहा हूं और मेरी पसंद है oslo.concurrency रही है
यह शक्तिशाली और अपेक्षाकृत अच्छी तरह से प्रलेखित है। यह फास्टनरों पर आधारित है।
अन्य उपाय:
लॉकिंग प्लेटफ़ॉर्म और डिवाइस विशिष्ट है, लेकिन आम तौर पर, आपके पास कुछ विकल्प होते हैं:
इन सभी तरीकों के लिए, आपको लॉक प्राप्त करने और परीक्षण करने के लिए स्पिन-लॉक (रिट्री-आफ्टर-फेल) तकनीक का उपयोग करना होगा। यह गलत सिंक्रनाइज़ेशन के लिए एक छोटी सी खिड़की छोड़ देता है, लेकिन इसका आम तौर पर छोटा होना एक बड़ा मुद्दा नहीं है।
यदि आप एक ऐसे समाधान की तलाश कर रहे हैं जो क्रॉस प्लेटफॉर्म है, तो आप किसी अन्य तंत्र के माध्यम से किसी अन्य सिस्टम में प्रवेश करना बेहतर समझते हैं (अगली सबसे अच्छी बात ऊपर एनएफएस तकनीक है)।
ध्यान दें कि sqlite NFS पर समान बाधाओं के अधीन है जो सामान्य फाइलें हैं, इसलिए आप नेटवर्क शेयर पर एक sqlite डेटाबेस में नहीं लिख सकते हैं और मुफ्त में सिंक्रनाइज़ेशन प्राप्त कर सकते हैं।
os.renameपायथन 3.3 के बाद से अब Win32 में परमाणु है: Bugs.python.org/issue8828
OS स्तर पर किसी एकल फ़ाइल तक पहुँच को समन्वयित करना उन सभी प्रकार के मुद्दों से भरा हुआ है जिन्हें आप शायद हल नहीं करना चाहते हैं।
आपकी सबसे अच्छी शर्त एक अलग प्रक्रिया है जो उस फ़ाइल के पढ़ने / लिखने का समन्वय करती है।
flockइसके लिए कार्यों के साथ पेश करता है। "अपने स्वयं के म्यूटेक्स को रोल करें और उन्हें प्रबंधित करने के लिए एक डेमन प्रक्रिया" को हल करने के लिए लेने के बजाय एक चरम और जटिल दृष्टिकोण की तरह लगता है ... एक समस्या जिसे आपने वास्तव में हमारे बारे में नहीं बताया है, लेकिन सिर्फ सुझाव दिया गया है।
किसी फ़ाइल को लॉक करना आमतौर पर एक प्लेटफ़ॉर्म-विशिष्ट ऑपरेशन होता है, इसलिए आपको अलग-अलग ऑपरेटिंग सिस्टम पर चलने की संभावना के लिए अनुमति देनी पड़ सकती है। उदाहरण के लिए:
import os
def my_lock(f):
if os.name == "posix":
# Unix or OS X specific locking here
elif os.name == "nt":
# Windows specific locking here
else:
print "Unknown operating system, lock unavailable"मैं इस तरह की स्थिति पर काम कर रहा हूं जहां मैं एक ही निर्देशिका / फ़ोल्डर और लॉगिंग त्रुटियों के भीतर से एक ही कार्यक्रम की कई प्रतियां चलाता हूं। मेरा दृष्टिकोण लॉग फाइल खोलने से पहले डिस्क को "लॉक फाइल" लिखना था। कार्यक्रम आगे बढ़ने से पहले "लॉक फाइल" की उपस्थिति की जांच करता है, और अगर "लॉक फाइल" मौजूद है, तो अपनी बारी का इंतजार करता है।
यहाँ कोड है:
def errlogger(error):
while True:
if not exists('errloglock'):
lock = open('errloglock', 'w')
if exists('errorlog'): log = open('errorlog', 'a')
else: log = open('errorlog', 'w')
log.write(str(datetime.utcnow())[0:-7] + ' ' + error + '\n')
log.close()
remove('errloglock')
return
else:
check = stat('errloglock')
if time() - check.st_ctime > 0.01: remove('errloglock')
print('waiting my turn')EDIT --- ऊपर बासी ताले के बारे में कुछ टिप्पणियों पर विचार करने के बाद मैंने "लॉक फ़ाइल" की गतिहीनता के लिए एक चेक जोड़ने के लिए कोड को संपादित किया। मेरे सिस्टम पर इस फ़ंक्शन के कई हज़ार पुनरावृत्तियों को दिया गया और 0.002066 का औसत ... कुछ ही समय पहले:
lock = open('errloglock', 'w')बस के बाद:
remove('errloglock')इसलिए मुझे लगा कि मैं 5 बार उस राशि के साथ शुरू करूंगा जो कि गतिहीनता को इंगित करती है और समस्याओं के लिए स्थिति की निगरानी करती है।
इसके अलावा, जैसा कि मैं समय के साथ काम कर रहा था, मुझे एहसास हुआ कि मेरे पास थोड़ा सा कोड था जो वास्तव में आवश्यक नहीं था:
lock.close()जो मैंने तुरंत खुले कथन का पालन किया था, इसलिए मैंने इसे इस संपादन में हटा दिया है।
इवान फॉसमार्क के उत्तर को जोड़ने के लिए , यहां एक उदाहरण दिया गया है कि फिलालॉक का उपयोग कैसे किया जाए :
from filelock import FileLock
lockfile = r"c:\scr.txt"
lock = FileLock(lockfile + ".lock")
with lock:
file = open(path, "w")
file.write("123")
file.close()with lock:ब्लॉक के भीतर कोई भी कोड थ्रेड-सुरक्षित है, जिसका अर्थ है कि यह किसी अन्य प्रक्रिया से फ़ाइल तक पहुंचने से पहले समाप्त हो जाएगा।
परिदृश्य है कि तरह है: उपयोगकर्ता कुछ करने के लिए एक फ़ाइल अनुरोध करता है। फिर, यदि उपयोगकर्ता फिर से वही अनुरोध भेजता है, तो यह उपयोगकर्ता को सूचित करता है कि पहला अनुरोध पूरा होने तक दूसरा अनुरोध नहीं किया गया है। इसीलिए, मैं इस मुद्दे को संभालने के लिए लॉक-मैकेनिज्म का उपयोग करता हूं।
यहाँ मेरा काम कोड है:
from lockfile import LockFile
lock = LockFile(lock_file_path)
status = ""
if not lock.is_locked():
lock.acquire()
status = lock.path + ' is locked.'
print status
else:
status = lock.path + " is already locked."
print status
return statusआपको plocklocker बहुत उपयोगी लग सकता है। इसका उपयोग किसी फाइल को लॉक करने के लिए या सामान्य तौर पर लॉकिंग मैकेनिज्म के लिए किया जा सकता है और एक ही बार में कई पायथन प्रक्रियाओं से इसे एक्सेस किया जा सकता है।
यदि आप बस एक फ़ाइल को यहाँ लॉक करना चाहते हैं तो यह कैसे काम करता है:
import uuid
from pylocker import Locker
# create a unique lock pass. This can be any string.
lpass = str(uuid.uuid1())
# create locker instance.
FL = Locker(filePath='myfile.txt', lockPass=lpass, mode='w')
# aquire the lock
with FL as r:
# get the result
acquired, code, fd = r
# check if aquired.
if fd is not None:
print fd
fd.write("I have succesfuly aquired the lock !")
# no need to release anything or to close the file descriptor,
# with statement takes care of that. let's print fd and verify that.
print fd