Metadata-Version: 1.1
Name: multiprocessing-utils
Version: 0.4
Summary: Multiprocessing utils (shared locks and thread locals)
Home-page: https://github.com/daggaz/python-multiprocessing-utils
Author: Jamie Cockburn and Andrew Binnie
Author-email: jamie_cockburn@hotmail.co.uk
License: MIT
Description-Content-Type: UNKNOWN
Description: ============================
        python-multiprocessing-utils
        ============================
        
        Multiprocessing utilities
        
        ************
        Shared locks
        ************
        
        "Shared" version of the standard ``Lock()`` and ``RLock()`` classes found in
        the ``multiprocessing``/``threading`` modules.
        
        Shared locks can be acquired in two modes, shared and exclusive.
        
        Any number of processes/threads can acquire the lock in shared mode.
        
        Only one process/thread can acquire the lock in exclusive mode.
        
        A process/thread attempting to exclusively acquire the lock will block
        until the lock has been released by all other threads/processes.
        
        A process/thread attempting to shared acquire the lock will only block
        while there is an exclusive lock.
        
        This is a little like database locks, which can be acquired for shared reading,
        or exclusive writing.
        
        ::
        
            lock = multiprocessing_utils.SharedLock()
        
            def exclusive_worker():
                with lock.exclusive():
                    # this code will only run when no other
                    # process/thread in a lock context
        
            def shared_worker():
                with lock:
                    # this code will run so long as no
                    # thread/process holds an exclusive lock
        
        ***************************************
        multiprocess-safe ``threading.local()``
        ***************************************
        
        A process (and thread) safe version of ``threading.local()``
        
        ::
        
            l = multiprocessing_utils.local()
            l.x = 1
        
            def f():
                try:
                    print(l.x)
                except Attribute:
                    print("x not set")
            f()                                        # prints "1"
            threading.Thread(target=f).start()         # prints "x not set"
            multiprocessing.Process(target=f).start()  # prints "x not set"
        
        Difference to standard ``threading.local()``
        --------------------------------------------
        
        A standard ``threading.local()`` instance created before forking (via
        ``os.fork()`` or ``multiprocessing.Process()``) will be "local" as expected
        and the new process will have access to any data set before the fork.
        
        Using a standard ``threading.local()`` in the example above would yield:
        
        ::
        
            f()                                        # prints "1"
            threading.Thread(target=f).start()         # prints "x not set"
            multiprocessing.Process(target=f).start()  # prints "1" :(
        
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 2
Classifier: Programming Language :: Python :: 2.7
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.3
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
