Khóa một tệp trong Python

Tôi cần phải khóa một tập tin để viết bằng Python. Nó sẽ được truy cập từ nhiều quá trình Python cùng một lúc. Tôi đã tìm thấy một số giải pháp trực tuyến, nhưng hầu hết đều thất bại vì mục đích của tôi vì chúng thường chỉ dựa trên Unix hoặc dựa trên Windows.

Được rồi, vì vậy tôi đã kết thúc với mã tôi đã viết ở đây, trên ^{liên kết} trang web của tôi ^{đã chết, xem trên archive.org} ( cũng có sẵn trên GitHub ). Tôi có thể sử dụng nó theo cách sau:

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

Có một mô-đun khóa tập tin đa nền tảng ở đây: Portalocker

Mặc dù như Kevin nói, viết vào một tệp từ nhiều quy trình cùng một lúc là điều bạn muốn tránh nếu có thể.

Nếu bạn có thể đưa vấn đề của mình vào cơ sở dữ liệu, bạn có thể sử dụng SQLite. Nó hỗ trợ truy cập đồng thời và xử lý khóa riêng của mình.

Các giải pháp khác trích dẫn rất nhiều cơ sở mã bên ngoài. Nếu bạn muốn tự làm điều đó, đây là một số mã cho giải pháp đa nền tảng sử dụng các công cụ khóa tệp tương ứng trên các hệ thống Linux / DOS.

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        

Bây giờ, AtomicOpencó thể được sử dụng trong một withkhối nơi người ta thường sử dụng một opencâu lệnh.

CẢNH BÁO: Nếu chạy trên Windows và Python gặp sự cố trước khi thoát được gọi, tôi không chắc hành vi khóa sẽ là gì.

CẢNH BÁO: Khóa được cung cấp ở đây là tư vấn, không tuyệt đối. Tất cả các quy trình có khả năng cạnh tranh phải sử dụng lớp "AtomicOpen".

Tôi thích lockfile - Khóa tệp độc lập với nền tảng

Tôi đã xem xét một số giải pháp để làm điều đó và lựa chọn của tôi là oslo.concurrency

Đó là tài liệu mạnh mẽ và tương đối tốt. Nó dựa trên ốc vít.

Các giải pháp khác:

• Portalocker : yêu cầu pywin32, đây là bản cài đặt exe, vì vậy không thể qua pip
• ốc vít : tài liệu kém
• lockfile : không dùng nữa
• flufl.lock : Khóa tệp an toàn NFS cho các hệ thống POSIX.
• Simpleflock : Bản cập nhật mới nhất 2013-07
• zc.lockfile : Bản cập nhật mới nhất 2016-06 (kể từ 2017-03)
• lock_file : Bản cập nhật cuối cùng trong năm 2007-10

Khóa là nền tảng và thiết bị cụ thể, nhưng nói chung, bạn có một vài tùy chọn:

1. Sử dụng flock () hoặc tương đương (nếu hệ điều hành của bạn hỗ trợ nó). Đây là khóa tư vấn, trừ khi bạn kiểm tra khóa, nó bị bỏ qua.
2. Sử dụng phương pháp khóa-sao chép-di chuyển-mở khóa, trong đó bạn sao chép tệp, ghi dữ liệu mới, sau đó di chuyển nó (di chuyển, không sao chép - di chuyển là một hoạt động nguyên tử trong Linux - kiểm tra hệ điều hành của bạn) và bạn kiểm tra sự tồn tại của tập tin khóa.
3. Sử dụng một thư mục như là một "khóa". Điều này là cần thiết nếu bạn viết thư cho NFS, vì NFS không hỗ trợ flock ().
4. Cũng có khả năng sử dụng bộ nhớ dùng chung giữa các quy trình, nhưng tôi chưa bao giờ thử điều đó; nó rất đặc trưng cho hệ điều hành.

Đối với tất cả các phương pháp này, bạn sẽ phải sử dụng kỹ thuật khóa xoay (thử lại sau thất bại) để có được và kiểm tra khóa. Điều này không để lại một cửa sổ nhỏ để đồng bộ hóa sai, nhưng nó thường đủ nhỏ để không phải là một vấn đề lớn.

Nếu bạn đang tìm kiếm một giải pháp đa nền tảng, thì tốt hơn hết bạn nên đăng nhập vào hệ thống khác thông qua một số cơ chế khác (điều tốt nhất tiếp theo là kỹ thuật NFS ở trên).

Lưu ý rằng sqlite phải chịu các ràng buộc tương tự đối với NFS như các tệp thông thường, vì vậy bạn không thể ghi vào cơ sở dữ liệu sqlite trên mạng chia sẻ và được đồng bộ hóa miễn phí.

Phối hợp truy cập vào một tệp duy nhất ở cấp HĐH có nhiều vấn đề mà bạn có thể không muốn giải quyết.

Đặt cược tốt nhất của bạn là có một quy trình riêng biệt phối hợp truy cập đọc / ghi vào tệp đó.

Khóa một tệp thường là một hoạt động dành riêng cho nền tảng, vì vậy bạn có thể cần phải cho phép khả năng chạy trên các hệ điều hành khác nhau. Ví dụ:

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"

Tôi đã làm việc trong một tình huống như thế này khi tôi chạy nhiều bản sao của cùng một chương trình từ trong cùng một thư mục / thư mục và lỗi đăng nhập. Cách tiếp cận của tôi là viết một "tệp khóa" vào đĩa trước khi mở tệp nhật ký. Chương trình kiểm tra sự hiện diện của "tệp khóa" trước khi tiếp tục và chờ đến lượt nếu "tệp khóa" tồn tại.

Đây là mã:

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 --- Sau khi suy nghĩ về một số ý kiến ​​về các khóa cũ ở trên, tôi đã chỉnh sửa mã để thêm kiểm tra tính ổn định của "tệp khóa". Thời gian vài nghìn lần lặp lại của chức năng này trên hệ thống của tôi đã cho và trung bình là 0,002066 ... giây so với trước đó:

lock = open('errloglock', 'w')

chỉ sau:

remove('errloglock')

Vì vậy, tôi nghĩ rằng tôi sẽ bắt đầu với số tiền gấp 5 lần để biểu thị sự ổn định và theo dõi tình hình cho các vấn đề.

Ngoài ra, khi tôi đang làm việc với thời gian, tôi nhận ra rằng tôi có một chút mã không thực sự cần thiết:

lock.close()

mà tôi đã ngay lập tức làm theo tuyên bố mở, vì vậy tôi đã loại bỏ nó trong chỉnh sửa này.

Để thêm vào câu trả lời của Evan Fossmark , đây là một ví dụ về cách sử dụng 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()

Bất kỳ mã nào trong with lock:khối đều an toàn cho luồng, nghĩa là nó sẽ được hoàn thành trước khi quá trình khác có quyền truy cập vào tệp.

Các kịch bản là như thế: Người dùng yêu cầu một tập tin để làm điều gì đó. Sau đó, nếu người dùng gửi lại cùng một yêu cầu, nó sẽ thông báo cho người dùng rằng yêu cầu thứ hai không được thực hiện cho đến khi yêu cầu đầu tiên kết thúc. Đó là lý do tại sao, tôi sử dụng cơ chế khóa để xử lý vấn đề này.

Đây là mã làm việc của tôi:

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

Tôi tìm thấy một cách thực hiện đơn giản và hiệu quả (!) Từ Grizzled-python.

Sử dụng đơn giản os.open (..., O_EXCL) + os.close () không hoạt động trên windows.

Bạn có thể thấy pylocker rất hữu ích. Nó có thể được sử dụng để khóa một tệp hoặc cho các cơ chế khóa nói chung và có thể được truy cập từ nhiều quy trình Python cùng một lúc.

Nếu bạn chỉ muốn khóa một tập tin ở đây thì nó hoạt động như thế nào:

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