Popular recipes tagged "locking"

Distributed lock manager for Python (Python)

2012-07-04T21:03:32-07:00

Python recipe 578194 by pavel (distributed, lock, locking, locks, manager, socket, thread, threading, wsgi). Revision 2.

Distributed lock manager provides mutex(es) over network. It is used to synchronize processes running on different machines, e.g. WSGI processes in case of web applications. Lock object is compatible with threading.Lock and can be used as a context manager ("with statement"). It can be easily modified to use UNIX sockets instead of TCP/IP. Communication protocol is text based.

First start server process:

$ chmod +x dlm.py
$ ./dlm.py

Usage:

from dlm import LockClient

client = LockClient('localhost', 27272, 'client_name')

lock = client.mkLock('lock_name')

lock.acquire()
# critical section here...
lock.release()

# using context manager
with lock:
    # critical section here...

Reader-Writer lock with priority for writers (Python)

2011-09-28T21:45:04-07:00

Python recipe 577803 by Mateusz Kobos (locking, threads). Revision 2.

The following class implements a reader-writer lock to use in the second readers-writers problem with python threads. In this problem, many readers can simultaneously access a share, and a writer has an exclusive access to this share. Additionally, the following constraints should be met: 1) no reader should be kept waiting if the share is currently opened for reading unless a writer is also waiting for the share, 2) no writer should be kept waiting for the share longer than absolutely necessary.

Simple Lock Classes Based on threading.Lock() (Python)

2011-10-19T21:26:39-07:00

Python recipe 577914 by Eric Snow (lock, locking).

Nothing fancy here. Locks can take many forms. Here are a few.

Fast, re-entrant, optimistic lock implemented in Cython (Python)

2010-07-27T20:25:20-07:00

Python recipe 577336 by Stefan Behnel (concurrency, lock, locking). Revision 3.

This is a C-level implementation of a fast, re-entrant, optimistic lock for CPython. It is written in Cython. Under normal conditions, it is about 10x faster than threading.RLock because it avoids all locking unless two or more threads try to acquire it at the same time. Under congestion, it is still about 10% faster than RLock due to being implemented in Cython.

Application lock (Python)

2009-08-22T13:00:35-07:00

Python recipe 576891 by Max Polk (file_lock, locking).

Ensures application runs only once.

Simple shelve with Linux file locking (Python)

2008-12-21T05:50:07-08:00

Python recipe 576591 by Michael Ihde (dynamic_method, locking, shelve).

The shelve module is a easy way to add persistence to your application via a DBM database. However, if you have multiple reader/writer combination you need to lock the file to prevent corruption. The shelve module itself does not provide locking because it is platform specific. If you only need Linux, this simple module provide an easy way to support locking using dynamically added methods.

Simple lock-queue via Memcached (Python)

2008-11-19T01:32:07-08:00

Python recipe 576567 by Tal Einat (concurrency, contextmanager, lock, locking, memcache, memcached, queue).

A simple lock-queue (FIFO) context manager implemented with Memcached.

In essence this is a normal lock, where the requests to acquire the lock are granted in the order in which they were originally made. Note that requests to acquire the lock are always blocking.