পাইথনে লেখার জন্য আমার একটি ফাইল লক করা দরকার। এটি একাধিক পাইথন প্রক্রিয়া থেকে একবারে অ্যাক্সেস করা হবে। আমি অনলাইনে কিছু সমাধান পেয়েছি তবে বেশিরভাগ ক্ষেত্রে আমার উদ্দেশ্য ব্যর্থ হয় কারণ সেগুলি প্রায়শই কেবল ইউনিক্স ভিত্তিক বা উইন্ডোজ ভিত্তিক থাকে।
উত্তর:
ঠিক আছে, তাই আমি এখানে আমার লেখা কোডটি দিয়ে শেষ করেছি , আমার ওয়েবসাইটের লিঙ্কটি মারা গেছে, আর্কাইভ.অর্গে দেখুন ( গিটহাবটিতেও উপলভ্য )। আমি এটি নিম্নলিখিত ফ্যাশনে ব্যবহার করতে পারি:
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এখানে একটি ক্রস-প্ল্যাটফর্ম ফাইল লকিং মডিউল রয়েছে: পোর্টালকার
যদিও কেভিন বলেছেন, একযোগে একাধিক প্রক্রিয়া থেকে কোনও ফাইলকে লেখার বিষয়টি আপনি যদি সম্ভব হয় তবে এড়াতে চান।
আপনি যদি কোনও সমস্যাটিকে কোনও ডাটাবেসে জুতা দিতে পারেন তবে আপনি এসকিউএলাইট ব্যবহার করতে পারেন। এটি সমবর্তী অ্যাক্সেস সমর্থন করে এবং এর নিজস্ব লকিং পরিচালনা করে।
অন্যান্য সমাধানগুলি প্রচুর বহিরাগত কোড বেসগুলি উদ্ধৃত করে। আপনি যদি নিজেরাই এটি করতে পছন্দ করেন তবে এখানে ক্রস-প্ল্যাটফর্ম সমাধানের জন্য কিছু কোড রয়েছে যা লিনাক্স / ডস সিস্টেমে সম্পর্কিত ফাইল লকিং সরঞ্জাম ব্যবহার করে।
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 হয়েছে rency
এটি শক্তিশালী এবং তুলনামূলকভাবে ভাল নথিভুক্ত। এটি ফাস্টেনারদের উপর ভিত্তি করে।
অন্যান্য সমাধান:
filelock (সর্বশেষ প্রকাশিত: মন্তব্যের সময় 18 মে, 2019)
লক করা প্ল্যাটফর্ম এবং ডিভাইস নির্দিষ্ট, তবে সাধারণত আপনার কয়েকটি বিকল্প থাকে:
এই সমস্ত পদ্ধতির জন্য, আপনাকে লকটি অর্জন এবং পরীক্ষা করার জন্য একটি স্পিন-লক (পুনরায় ব্যর্থতার পরে চেষ্টা) কৌশল ব্যবহার করতে হবে। এটি ভুল-সিঙ্ক্রোনাইজেশনের জন্য একটি ছোট উইন্ডো ছেড়ে দেয়, তবে এটি সাধারণভাবে যথেষ্ট ছোট একটি বড় সমস্যা নয় be
যদি আপনি এমন কোনও সমাধান খুঁজছেন যা ক্রস প্ল্যাটফর্ম, তবে আপনি অন্য কোনও সিস্টেমের মাধ্যমে অন্য সিস্টেমে লগইন করা ভাল (পরবর্তী সর্বোত্তম জিনিসটি উপরের এনএফএস কৌশল)।
নোট করুন যে স্ক্লাইটটি এনএফএসের তুলনায় সাধারণ ফাইলগুলি যেমন একই সীমাবদ্ধতার সাপেক্ষে, সুতরাং আপনি কোনও নেটওয়ার্ক শেয়ারে একটি স্ক্লাইট ডাটাবেসে লিখতে পারবেন না এবং বিনামূল্যে সিঙ্ক্রোনাইজেশন পাবেন।
ওএস স্তরে একক ফাইলে অ্যাক্সেসের সমন্বয় করা এমন সমস্ত ধরণের সমস্যার সাথে পরিপূর্ণ যা আপনি সম্ভবত সমাধান করতে চান না।
আপনার সেরা বেটে একটি পৃথক প্রক্রিয়া রয়েছে যা সেই ফাইলটিতে পঠন / লেখার অ্যাক্সেসকে সমন্বয় করে।
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')সম্পাদনা করুন --- উপরে বাসি লকগুলি সম্পর্কে কিছু মন্তব্য করার পরে আমি "লক ফাইল" -এর বাসির জন্য একটি চেক যুক্ত করার জন্য কোডটি সম্পাদনা করেছি। আমার সিস্টেমে এই ফাংশনটির কয়েক হাজার পুনরাবৃত্তি করার সময় দেওয়া হয়েছে এবং ঠিক আগে থেকে 0.002066 ... সেকেন্ডে গড়:
lock = open('errloglock', 'w')ঠিক পরে:
remove('errloglock')সুতরাং আমি বুঝতে পেরেছি যে বাসিটি নির্দেশ করতে এবং সমস্যার পরিস্থিতি পর্যবেক্ষণ করতে আমি এই পরিমাণটি 5 গুণ দিয়ে শুরু করব।
এছাড়াও, সময়টি নিয়ে কাজ করার সময় আমি বুঝতে পেরেছিলাম যে আমার একটি কোড রয়েছে যা সত্যই প্রয়োজনীয় ছিল না:
lock.close()যা আমি অবিলম্বে প্রকাশ্য বিবৃতিটি অনুসরণ করেছি, তাই আমি এই সম্পাদনাটিতে এটি সরিয়েছি।
উপর যোগ করতে ইভান Fossmark এর উত্তর , এখানে কিভাবে ব্যবহার করতে একটি উদাহরণ filelock :
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গ্রিজল্ড-পাইথন থেকে আমি একটি সহজ এবং কাজ (!) বাস্তবায়ন পেয়েছি।
সাধারণ ব্যবহারের জন্য os.open (..., O_EXCL) + os.close () উইন্ডোতে কাজ করে না।
আপনি পাইলকারকে খুব দরকারী বলে মনে করতে পারেন । এটি কোনও ফাইল লক করতে বা সাধারণভাবে লক করার পদ্ধতিতে ব্যবহৃত হতে পারে এবং একাধিক পাইথন প্রক্রিয়া থেকে একবারে অ্যাক্সেস করা যায়।
আপনি যদি কেবল কোনও ফাইল লক করতে চান তবে এটি কীভাবে কাজ করে তা এখানে:
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