Mengunci file dengan Python

Saya perlu mengunci file untuk menulis dengan Python. Ini akan diakses dari beberapa proses Python sekaligus. Saya telah menemukan beberapa solusi online, tetapi sebagian besar gagal untuk tujuan saya karena seringkali hanya berbasis Unix atau berbasis Windows.

Baiklah, akhirnya saya menemukan kode yang saya tulis di sini, di ^tautan situs web saya ^{sudah mati, lihat di archive.org} ( juga tersedia di GitHub ). Saya bisa menggunakannya dengan cara berikut:

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

Ada modul penguncian file lintas-platform di sini: Portalocker

Meskipun seperti kata Kevin, menulis ke file dari berbagai proses sekaligus adalah sesuatu yang ingin Anda hindari jika memungkinkan.

Jika Anda dapat memperbaiki masalah Anda ke dalam database, Anda bisa menggunakan SQLite. Ini mendukung akses bersamaan dan menangani pengunciannya sendiri.

Solusi lain mengutip banyak basis kode eksternal. Jika Anda lebih suka melakukannya sendiri, berikut adalah beberapa kode untuk solusi lintas-platform yang menggunakan masing-masing alat penguncian file pada sistem 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        

Sekarang, AtomicOpendapat digunakan di withblok di mana orang biasanya menggunakan openpernyataan.

PERINGATAN: Jika berjalan pada Windows dan Python crash sebelum keluar dipanggil, saya tidak yakin apa perilaku kunci itu.

PERINGATAN: Penguncian yang disediakan di sini adalah saran, bukan mutlak. Semua proses yang berpotensi bersaing harus menggunakan kelas "AtomicOpen".

Saya lebih suka lockfile - Penguncian file yang bebas platform

Saya telah mencari beberapa solusi untuk melakukan itu dan pilihan saya adalah oslo.concurrency

Ini kuat dan relatif terdokumentasi dengan baik. Ini didasarkan pada pengencang.

Solusi lain:

• Portalocker : membutuhkan pywin32, yang merupakan instalasi exe, jadi tidak mungkin melalui pip
• pengencang : didokumentasikan dengan buruk
• lockfile : usang
• flufl.lock : Penguncian file aman-NFS untuk sistem POSIX.
• simpleflock : Pembaruan terakhir 2013-07
• zc.lockfile : Pembaruan terakhir 2016-06 (mulai 2017-03)
• lock_file : Pembaruan terakhir pada 2007-10

Mengunci adalah platform dan perangkat khusus, tetapi secara umum, Anda memiliki beberapa opsi:

1. Gunakan flock (), atau setara (jika os Anda mendukungnya). Ini adalah penguncian penasihat, kecuali jika Anda memeriksa kuncinya, diabaikan.
2. Gunakan metodologi lock-copy-move-unlock, di mana Anda menyalin file, menulis data baru, kemudian memindahkannya (pindah, bukan salin - pindah adalah operasi atom di Linux - periksa OS Anda), dan Anda memeriksa keberadaan file kunci.
3. Gunakan direktori sebagai "kunci". Ini diperlukan jika Anda menulis ke NFS, karena NFS tidak mendukung flock ().
4. Ada juga kemungkinan menggunakan memori bersama antara proses, tetapi saya belum pernah mencobanya; ini sangat spesifik untuk OS.

Untuk semua metode ini, Anda harus menggunakan teknik spin-lock (coba-setelah-kegagalan) untuk mendapatkan dan menguji kunci. Ini meninggalkan jendela kecil untuk kesalahan sinkronisasi, tetapi umumnya cukup kecil untuk tidak menjadi masalah besar.

Jika Anda mencari solusi yang lintas platform, maka Anda lebih baik masuk ke sistem lain melalui beberapa mekanisme lain (hal terbaik berikutnya adalah teknik NFS di atas).

Perhatikan bahwa sqlite tunduk pada batasan yang sama pada NFS dengan file normal, jadi Anda tidak dapat menulis ke database sqlite pada jaringan berbagi dan mendapatkan sinkronisasi secara gratis.

Mengoordinasikan akses ke satu file pada level OS penuh dengan segala macam masalah yang mungkin tidak ingin Anda selesaikan.

Taruhan terbaik Anda adalah memiliki proses terpisah yang mengoordinasikan akses baca / tulis ke file itu.

Mengunci file biasanya operasi platform-spesifik, jadi Anda mungkin perlu untuk memungkinkan kemungkinan berjalan pada sistem operasi yang berbeda. Sebagai contoh:

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"

Saya telah bekerja pada situasi seperti ini di mana saya menjalankan banyak salinan dari program yang sama dari dalam direktori / folder yang sama dan kesalahan logging. Pendekatan saya adalah menulis "file kunci" ke disk sebelum membuka file log. Program memeriksa keberadaan "file kunci" sebelum melanjutkan, dan menunggu gilirannya jika "file kunci" ada.

Ini kodenya:

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

Sunting --- Setelah memikirkan beberapa komentar tentang kunci basi di atas saya mengedit kode untuk menambahkan cek untuk staleness dari "file kunci." Waktu beberapa ribu iterasi fungsi ini pada sistem saya memberi dan rata-rata 0,002066 ... detik dari sebelum:

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

hanya setelah:

remove('errloglock')

jadi saya pikir saya akan mulai dengan 5 kali jumlah itu untuk menunjukkan staleness dan memonitor situasi untuk masalah.

Juga, ketika saya sedang mengerjakan pengaturan waktu, saya menyadari bahwa saya memiliki sedikit kode yang tidak terlalu diperlukan:

lock.close()

yang saya segera ikuti pernyataan terbuka, jadi saya telah menghapusnya di edit ini.

Untuk menambahkan jawaban Evan Fossmark , berikut adalah contoh cara menggunakan 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()

Kode apa pun di dalam with lock:blok adalah thread-safe, artinya kode itu akan selesai sebelum proses lain memiliki akses ke file.

The skenario seperti itu: Pengguna meminta file untuk melakukan sesuatu. Kemudian, jika pengguna mengirim permintaan yang sama lagi, itu memberi tahu pengguna bahwa permintaan kedua tidak dilakukan sampai permintaan pertama selesai. Itu sebabnya, saya menggunakan mekanisme kunci untuk menangani masalah ini.

Ini kode kerja saya:

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

Saya menemukan implementasi (!) Yang sederhana dan berhasil dari grizzled-python.

Penggunaan sederhana os.open (..., O_EXCL) + os.close () tidak berfungsi di windows.

Anda mungkin menemukan pylocker sangat berguna. Ini dapat digunakan untuk mengunci file atau untuk mekanisme penguncian secara umum dan dapat diakses dari beberapa proses Python sekaligus.

Jika Anda hanya ingin mengunci file, inilah cara kerjanya:

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