Demonstration of Python threading.RLock

lock_test.py

from threading import RLock, Thread
import copy
import datetime
import random
import time


class SharedObject(object):
    def __init__(self):
        self._shared_variable = None

        self._lock = RLock()

    @property
    def shared_variable(self):
        with self._lock:
            return copy.copy(self._shared_variable)

    @shared_variable.setter
    def shared_variable(self, shared_variable):
        with self._lock:
            self._shared_variable = copy.copy(shared_variable)


def write_worker(index, shared_object):
    global _STOP_THREADS

    while not _STOP_THREADS:
        shared_variable = random.randint(0, 255)
        before = datetime.datetime.now()
        shared_object.shared_variable = shared_variable
        after = datetime.datetime.now()
        print 'thread {0} wrote {1} in {2}'.format(
            index, shared_variable, after - before
        )
        time.sleep(1)


def read_worker(index, shared_object):
    global _STOP_THREADS

    while not _STOP_THREADS:
        before = datetime.datetime.now()
        shared_variable = shared_object.shared_variable
        after = datetime.datetime.now()
        print 'thread {0} read {1} in {2}'.format(
            index, shared_variable, after - before
        )
        time.sleep(1)


_STOP_THREADS = False

so = SharedObject()

ts = []
for i in range(0, 512):
    ts += [Thread(
        target=write_worker if i % 2 == 0 else read_worker,
        args=(i, so,)
    )]
    ts[-1].start()

while 1:
    try:
        time.sleep(1)
    except KeyboardInterrupt:
        _STOP_THREADS = True
        break

for t in ts:
    t.join()

This script defines a SharedObject with RLock protection around a property called "shared_variable".

It then spins up 512 threads; half of them write to the object, half of them read from it.