---
id: zc-lockfile
version: "4.0"
license: ZPL-2.1
license_treatment: unclear
maintenance: aging
---

# zc.lockfile — Basic inter-process locks

License: unclear · Maintenance: aging · Downloads: 3.2M/mo

## What it is and what it does

zc.lockfile is a lightweight library for creating and managing inter-process locks using the filesystem. Rather than locking files themselves, it uses lock files as a coordination mechanism—the actual resource being protected can be any shared state. The library provides a LockFile class that acquires an OS-level lock on a named file; attempting to lock the same file from another process raises LockError. Lock files persist after release and can optionally include process ID and hostname information for debugging in containerized environments.

The package is designed for scenarios where multiple processes need to serialize access to a shared resource without a dedicated lock server. It is commonly used by database implementations (like ZODB file storage) to mediate access to data files. The implementation is portable across Windows and POSIX systems and supports both CPython and PyPy.

Use it for:

- Serialize access to a shared database file from multiple worker processes in a multiprocessing application.
- Prevent concurrent writes to a configuration or state file in a distributed system.
- Coordinate startup or initialization across multiple container instances by using a lock file on a shared volume.
- Implement a simple job-locking mechanism to ensure only one instance of a scheduled task runs at a time.
- Mediate access to a shared resource in a legacy system that predates modern concurrency primitives.

## Worth the install?

AI-flagged interpretation of the facts above — verify before relying.

Provides portable inter-process locks implemented using lock files and OS-level file-locking primitives, allowing multiple processes to coordinate access to shared resources.

Yes, if you need portable file-based inter-process locking without external dependencies. The package is stable, actively maintained, and has no known vulnerabilities. The aging maintenance status (330 days since last release) is not a concern given the mature, narrow scope of the library. The unclear license treatment warrants a quick review if you have strict licensing requirements, but the ZPL-2.1 is OSI-approved and widely used in the Zope ecosystem.

## Install

pip install zc-lockfile
uv add zc-lockfile
poetry add zc-lockfile

## Installing zc.lockfile

Before you install: Low friction: pure Python wheel with only setuptools as a runtime dependency. Maintenance status is aging—last release was 330 days ago—but the repository remains active with recent commits and no archived status.

License in practice: Licensed under ZPL-2.1 (Zope Public License), which is OSI-approved but less common than MIT or Apache 2.0. License treatment is marked unclear; review the license terms if proprietary use or redistribution is planned.

Quickstart:

import zc.lockfile

lock = zc.lockfile.LockFile('mylock')
try:
    # critical section
    pass
finally:
    lock.close()

Requires Python 3.9 or later; does not support Python 3.7 or 3.8.

Verify before relying:

- Whether the ZPL-2.1 license is compatible with your project's licensing constraints
- Performance characteristics under high contention or with many concurrent lock attempts
- Behavior on network filesystems or non-POSIX systems beyond Windows and POSIX

## Package facts

- License: ZPL-2.1 (unclear)
- Python support: supports_current
- Install friction: low
- Maintenance: aging
- Downloads: 3.2M/month (top 5,000 on PyPI)
- Known vulnerabilities: none known

## Tags

inter-process locking, file-based locks, process synchronization, lock file implementation, concurrent access control, multiprocess coordination, portable file locks, concurrency, file-locking, ipc

[View on SkillFed](https://skillfed.io/packages/zc-lockfile) · [View on PyPI](https://pypi.org/project/zc-lockfile/)