Python thread local

　　由于GIL的原因，笔者在日常开发中几乎没有用到python的多线程。如果需要并发，一般使用多进程，对于IO Bound这种情况，使用协程也是不错的注意。但是在python很多的网络库中，都支持多线程，基本上都会使用到threading.local。在python中threading.local用来表示线程相关的数据，线程相关指的是这个属性再各个线程中是独立的 互不影响，先来看一个最简答的例子：

 　　

class Widgt(object):
    pass

import threading
def test():
    local_data = threading.local()
    # local_data = Widgt()
    local_data.x = 1

    def thread_func():
        print('Has x in new thread: %s' % hasattr(local_data, 'x'))
        local_data.x = 2

    t = threading.Thread(target = thread_func)
    t.start()
    t.join()
    print('x in pre thread is %s' % local_data.x)

if __name__ == '__main__':
    test()

输出：

    Has x in new thread: False

    x in pre thread is 1

 

　　可以看到，在新的线程中 local_data 并没有x属性，并且在新线程中的赋值并不会影响到其他线程。也可以稍微改改代码，去掉第7行的注释，local_data就变成了线程共享的变量。

 

　　local怎么实现的呢 在threading.py 代码如下：

　　

try:
    from thread import _local as local
except ImportError:
    from _threading_local import local

 

　　可以看到，local是python的buildin class，同时也提供了一个纯python版本的参考实现，在_threading_local.py，我们来看看代码（代码不全 省略了几个函数）：

　　

class _localbase(object):
    __slots__ = '_local__key', '_local__args', '_local__lock'

    def __new__(cls, *args, **kw):
        self = object.__new__(cls)
        key = '_local__key', 'thread.local.' + str(id(self)) # 产生一个key，这个key在同一个进程的多个线程中是一样的
        object.__setattr__(self, '_local__key', key)
        object.__setattr__(self, '_local__args', (args, kw))
        object.__setattr__(self, '_local__lock', RLock()) # 可重入的锁

        if (args or kw) and (cls.__init__ is object.__init__):
            raise TypeError("Initialization arguments are not supported")

        # We need to create the thread dict in anticipation of
        # __init__ being called, to make sure we don't call it
        # again ourselves.
        dict = object.__getattribute__(self, '__dict__')
        current_thread().__dict__[key] = dict   # 在current_thread这个线程唯一的对象的—__dict__中加入 key

        return self

def _patch(self):
    key = object.__getattribute__(self, '_local__key')
    d = current_thread().__dict__.get(key)    # 注意 current_thread 在每一个线程是不同的对象
    if d is None: # 在新的线程第一次调用时
        d = {}    # 一个空的dict ！！！
        current_thread().__dict__[key] = d 
        object.__setattr__(self, '__dict__', d) # 将实例的__dict__赋值为 线程独立的一个字典

        # we have a new instance dict, so call out __init__ if we have
        # one
        cls = type(self)
        if cls.__init__ is not object.__init__:
            args, kw = object.__getattribute__(self, '_local__args')
            cls.__init__(self, *args, **kw)
    else:
        object.__setattr__(self, '__dict__', d)

class local(_localbase):

    def __getattribute__(self, name):
        lock = object.__getattribute__(self, '_local__lock')
        lock.acquire()
        try:
            _patch(self) # 这条语句执行之后，self.__dict__ 被修改成了线程独立的一个dict
            return object.__getattribute__(self, name)
        finally:
            lock.release()

 

 　　代码中 已经加入了注释，便于理解。总结就是，在每个线程中增加一个独立的dict（通过current_thread()这个线程独立的对象），然后每次对local实例增删改查的时候，进行__dict__的替换。我们看看测试代码：

　　

import threading
from _threading_local import local
def test():
    local_data = local()
    local_data.x = 1
    print 'id of local_data', id(local_data)

    def thread_func():
        before_keys = threading.current_thread().__dict__.keys()
        local_data.x = 2
        after = threading.current_thread().__dict__
        # print set(after.keys())  - set(before.keys())
        print [(e, v) for (e, v) in after.iteritems() if e not in before_keys]

    t = threading.Thread(target = thread_func)
    t.start()
    t.join()
    print('x in pre thread is %s' % local_data.x)

if __name__ == '__main__':
    test()

 输出：

　　id of local_data 40801456
　　[(('_local__key', 'thread.local.40801456'), {'x': 2})]

　　从输出可以看到，在这次运行总，local_data的id是40801456，在每个线程中都是一样的。在新的线程（thread_func函数）中访问local_data对象之前，current_thread()返回的对象是没有__local_key的，在第10行访问的时候会增加这个属性（_patch函数中）。

　　

　　在gevent中，也有一个类叫local，其作用是提供协程独立的数据。PS：gevent中提供了几乎与python原生协程一样的数据结构，如Event、Semaphore、Local，而且，gevent的代码和文档中也自称为“thread”，这点需要注意。gevent.local的实现借鉴了上面介绍的_threading_local.py, 区别在于，_threading_local.local 将线程独立的数据存放在current_thread()中，而gevent.local将协程独立的数据存放在greenlet.getcurrent()中。

 

 　　最后，如果在代码中使用了gevent.monkey.patch_all()，那么python原生的threading.local将会被替换成gevent.local.local。之前在看bottle的代码的时候，发现里面都是使用的threading.local，当时也对monkey_patch具体patch了那些模块不了解，于是就想如果使用gevent是否会出错呢，结果测试了很久都发现没问题，直到重新细看bottle源码才发现原因所在。代码如下：

　　

class GeventServer(ServerAdapter):
    """ Untested. Options:

        * See gevent.wsgi.WSGIServer() documentation for more options.
    """

    def run(self, handler):
        from gevent import pywsgi, local
        if not isinstance(threading.local(), local.local): ＃注意这里
            msg = "Bottle requires gevent.monkey.patch_all() (before import)"
            raise RuntimeError(msg)
        if self.quiet:
            self.options['log'] = None
        address = (self.host, self.port)
        server = pywsgi.WSGIServer(address, handler, **self.options)
        if 'BOTTLE_CHILD' in os.environ:
            import signal
            signal.signal(signal.SIGINT, lambda s, f: server.stop())
        server.serve_forever()

　　这个小插曲其实也反映了monkey-patch的一些优势与劣势。其优势在于不对源码修改就能改变运行时行为，提高性能；同时 ，对于缺乏经验或者对patch细节不了解的人来说，会带来静态代码与运行结果之间的认知差异。

 

references：

bottle.py源码 

gevent tutorial