在Python中锁定文件

Question

我需要锁定一个文件以用Python编写。它将一次从多个Python进程访问。我在网上找到了一些解决方案，但是大多数解决方案都失败了，因为它们通常只有基于Unix或Windows。

Answer 1

好了，所以我最终的代码要我写 here, on my website ^{link is dead, view on archive.org}（also available on GitHub）。我可以通过以下方式使用它：

from filelock import FileLock 

with FileLock("myfile.txt"): 
    # work with the file as it is now locked 
    print("Lock acquired.") 

Answer 2

锁定文件通常是特定于平台的操作，因此您可能需要考虑在不同操作系统上运行的可能性。例如：

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" 

Answer 3

协调对操作系统级别的单个文件的访问充满了各种您可能不想解决的问题。

你最好打赌的是有一个单独的进程，协调对该文件的读/写访问。

Answer 4

有一个跨平台的文件锁定模块的位置：Portalocker

虽然凯文说，写从多个进程同时文件是你想避免，如果在所有可能的东西。

如果您可以将您的问题解决到数据库中，则可以使用SQLite。它支持并发访问并处理自己的锁定。

Answer 5

锁定是平台和特定的设备，但通常，你有几种选择：

1. 用羊群（），或equivilent（如果您的操作系统支持）。这是建议性锁定，除非您检查锁定，否则将其忽略。
2. 使用锁复制移动解锁方法，您可以在其中复制文件，写入新数据，然后移动它（移动，而不是复制 - 移动是Linux中的原子操作 - 检查您的操作系统），而您检查锁定文件的存在。
3. 使用一个目录作为“锁”。如果你正在写入NFS，这是必须的，因为NFS不支持flock（）。
4. 也有可能在进程之间使用共享内存，但我从来没有尝试过;它非常特定于操作系统。

对于所有这些方法，您必须使用自旋锁定（故障后重试）技术来获取和测试锁定。这确实给失步留下了一个小窗口，但它通常足够小，不会成为主要问题。

如果你正在寻找一个跨平台的解决方案，那么你最好通过其他机制登录到另一个系统（其次最好的是上面的NFS技术）。

请注意，sqlite受到与普通文件相同的NFS约束，因此您无法写入网络共享上的sqlite数据库并获得免费的同步。

Answer 6

我喜欢lockfile - 平台无关的文件锁定

Answer 7

我发现了一个简单的工作（！）来自grizzled-python的implementation。

简单使用os.open（...，O_EXCL）+ os.close（）在windows上不起作用。

Answer 8

我一直在努力处理这种情况，我在同一目录/文件夹中运行同一程序的多个副本并记录错误。我的方法是在打开日志文件之前写入“锁定文件”到光盘。程序在继续之前检查是否存在“锁定文件”，如果存在“锁定文件”，则等待它。

这里是代码：“锁定文件”

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() 

，我曾紧随公开声明，所以我已删除了它在这个编辑中。

Answer 9

我一直在寻找多种解决方案做到这一点，我选择一直 oslo.concurrency

它的强大和相对有据可查。它基于紧固件。

其他的解决方案：

• Portalocker：需要pywin32，这是一个exe安装，所以无法通过PIP
• fasteners：记录不
• lockfile：弃用
• flufl.lock：NFS安全文件锁定POSIX系统。
• simpleflock：最后更新2013年7月
• zc.lockfile：更新2016-06（截至2017-03）
• lock_file：在2007-10

Answer 10

最新更新你会发现pylocker非常有用。它可以用来锁定一个文件或锁定机制，可以一次从多个Python进程访问。

如果您只是想锁定文件，这里是它的工作原理是：

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 

Answer 11

的场景是这样的： 用户请求的文件做一些事情。然后，如果用户再次发送相同的请求，它会通知用户第二个请求没有完成，直到第一个请求结束。这就是为什么我使用锁定机制来处理这个问题。

这是我工作的代码：

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 

Answer 12

其他的解决方案列举了大量的外部代码库。如果您更愿意自己动手​​，那么下面是一些跨平台解决方案的代码，它使用Linux/DOS系统上各自的文件锁定工具。

try: 
    # Posix based file locking (Linux, Ubuntu, MacOS, etc.) 
    import fcntl 
    def lock_file(f): 
     fcntl.lockf(f, fcntl.LOCK_EX) 
    def unlock_file(f): pass 
except ModuleNotFoundError: 
    # Windows file locking 
    import msvcrt 
    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 
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 

    # Allows users to use the 'close' function if they want, in case 
    # the user did not have the AtomicOpen in a "with" block. 
    def close(self): self.__exit__() 

    # Unlock the file and close the file object 
    def __exit__(self, exc_type=None, exc_value=None, traceback=None):   
     # 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”可用于任何通常使用“open”语句的地方。

警告：如果在Windows和Python上运行退出之前崩溃被调用，我不确定锁定行为是什么。

警告：此处提供的锁定是建议性的，不是绝对的。所有潜在的竞争进程必须使用“AtomicOpen”类。