Thread-specific storage (Python recipe) by John E. Barham

ActiveState Code (http://code.activestate.com/recipes/66429/)

Bug-fix to single-threaded version. Oops...

try:
    import thread
except:
    def get_thread_storage():
        return {}

is wrong since it returns a different dictionary instance every time it is called. It should be:

try:
    import thread
except:
    _tss = {}
    def get_thread_storage():
        return _tss

Problem with get_ident(). The id's returned by get_ident are only unique to the currently active threads, so when a thread dies its id (and storage) might get used by another thread.

I don't know how often this could bite you in practice, but maybe there should be a clear_storage()-function that a thread can call when it's done.

_tss dictionary is not multi-threading protected. The TSS implementation is based on a "global" variable that can be accessed by all threads within a process. Currently, potential problems occur when a TSS entry is created for a new thread or when a TSS entry is removed. Both action can lead to a restructering of the internal dictionary structure. Threads that access their TSS variable at this may obtain a access to "dangling" or corrupted TSS data.

As already stated by a comment above, a thread that creates an TSS entry shoulds also removed again when it dies or is killed.

Thread-safe get_thread_storage(). Yup, there does exist a potential race condition when changing the global _tss dictionary. Anyway, this should fix that:

...
else:
    _tss = {}
    _tss_lock = thread.allocate_lock()
    def get_thread_storage():
        """Return a thread-specific storage dictionary."""
        thread_id = thread.get_ident() # Identify the calling thread.
        tss = _tss.get(thread_id)
        if tss is None: # First time being called by this thread.
            try: # Entering critical section.
                _tss_lock.acquire()
                _tss[thread_id] = tss = {} # Create a thread-specific dictionary.
            finally:
                _tss_lock.release()
        return tss

As to the problem of deleting thread-specific storage on thread death, that is an issue since thread ids can be recycled. However, I use get_thread_storage() in a program that has a pool of "worker" threads that live as long as the main thread so it isn't a problem in this scenario.

Writing a corresponding delete_thread_storage() is thus left as an Exercise for the Reader, ;), but it is symmetric to get_thread_storage().

Updated source reflects bug-fix comments. The updated source code now incorporates the changes I made in earlier comments.

better get_thread_storage.

def get_thread_storage(_get_ident=thread.get_ident):#make thread.get_ident a local var

"""Return a thread-specific storage dictionary."""

thread_id = _get_ident() # Identify the calling thread.

try:

    return _tss[thread_id]

except KeyError:

    tss = _tss[thread_id]={}

    return tss

I don't need a lock because only a exists one thread with thread_id.