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