摘要：線程局部變量，也就是每個線程的私有變量，具有線程隔離性。按我們正常的理解，應該是每一個請求對應一個處理線程。在中，除了線程之外，還有個叫協程的東東，這里不提進程。配合會確保不管是協程還是線程，只要當前請求處理完成之后清除中對應的內容。

首先貼出官方文檔地址：http://werkzeug.pocoo.org/doc...
幾個local？
threading.local
werkzeug.local模塊中的：
Local
LocalStack
LocaProxy

why not threading.local?

threading.local,以前接觸過java的，對這個再熟悉不過了。線程局部變量，也就是每個線程的私有變量，具有線程隔離性。

按我們正常的理解，應該是每一個http請求對應一個處理線程。那么這樣看來使用threading.local應該夠了，為什么werkzeug還自己搞了一套？裝逼？非也。

在python中，除了線程之外，還有個叫協程的東東，(這里不提進程)。java中貌似是無法實現協程的。而python的協程感覺高大尚的樣子，python3.5開始對協程內置支持，而且也有相關開源庫greenlet等。

協程是什么？
舉個例子，比如一個線程在處理IO時，該線程是處于空閑狀態的，等待IO返回。但是此時如果不讓我們的線程干等著cpu時間片耗光，有沒有其他辦法，解決思路就是采用協程處理任務，一個線程中可以運行多個協程，當當前協程去處理IO時，線程可以馬上調度其他協程繼續運行，而不是干等著不干活。

這么一說，我們知道了協程會復用線程，WSGI不保證每個請求必須由一個線程來處理，如果WSGI服務器不是每個線程派發一個請求，而是每個協程派發一個請求，所以如果使用thread local變量可能會造成請求間數據相互干擾，因為一個線程中存在多個請求。
所以werkzeug給出了自己的解決方案：werkzeug.local模塊。

from werkzeug.local import Local, LocalManager

local = Local()
local_manager = LocalManager([local])

def application(environ, start_response):
    local.request = request = Request(environ)
    ...

application = local_manager.make_middleware(application)

Local配合LocalManager會確保不管是協程還是線程，只要當前請求處理完成之后清除Local中對應的內容。

>>> loc = Local()
>>> loc.foo = 42
>>> release_local(loc)
>>> hasattr(loc, "foo")

當然，你也可以調用werkzeug.local.release_local(local)手動釋放Local或者LocalStack ，但是不能清除代理對象LocalProxy(代理對象底層保留了對Local對象的引用，以便在之后釋放)的數據。

>>> ls = LocalStack()
>>> ls.push(42)
>>> ls.top
42
>>> ls.push(23)
>>> ls.top
23
>>> ls.pop()
23
>>> ls.top

LocalStack，與Local類似，但是管理數據的方式是采用棧的方式，可以通過LocalManager對象強制釋放，但是不建議這么做，而是通過其pop方法彈出。

from werkzeug.local import Local
l = Local()

# these are proxies
request = l("request")
user = l("user")


from werkzeug.local import LocalStack
_response_local = LocalStack()

# this is a proxy
response = _response_local()

werkzeug.local.LocalProxy:Local對象的一個代理。如果你需要創建Local或LocalStack對象的代理，可以直接call。

session = LocalProxy(lambda: get_current_request().session)

from werkzeug.local import Local, LocalProxy
local = Local()
request = LocalProxy(local, "request")

>>> from werkzeug.local import LocalProxy
>>> isinstance(request, LocalProxy)
True

你也可以通過LocalProxy構造一個代理對象，參數為可以調用的對象或者函數。
_get_current_object()返回被代理的對象。

werkzeug.local模塊關鍵部分代碼：

import copy
from functools import update_wrapper
from werkzeug.wsgi import ClosingIterator
from werkzeug._compat import PY2, implements_bool
try:
    from greenlet import getcurrent as get_ident
except ImportError:
    try:
        from thread import get_ident
    except ImportError:
        from _thread import get_ident


def release_local(local):
    local.__release_local__()


class Local(object):
    __slots__ = ("__storage__", "__ident_func__")

    def __init__(self):
        object.__setattr__(self, "__storage__", {})
        object.__setattr__(self, "__ident_func__", get_ident)

    def __iter__(self):
        return iter(self.__storage__.items())

    def __call__(self, proxy):
        """Create a proxy for a name."""
        return LocalProxy(self, proxy)

    def __release_local__(self):
        self.__storage__.pop(self.__ident_func__(), None)

    def __getattr__(self, name):
        try:
            return self.__storage__[self.__ident_func__()][name]
        except KeyError:
            raise AttributeError(name)

    def __setattr__(self, name, value):
        ident = self.__ident_func__()
        storage = self.__storage__
        try:
            storage[ident][name] = value
        except KeyError:
            storage[ident] = {name: value}

    def __delattr__(self, name):
        try:
            del self.__storage__[self.__ident_func__()][name]
        except KeyError:
            raise AttributeError(name)


class LocalStack(object):

    def __init__(self):
        self._local = Local()

    def __release_local__(self):
        self._local.__release_local__()

    def __call__(self):
        def _lookup():
            rv = self.top
            if rv is None:
                raise RuntimeError("object unbound")
            return rv
        return LocalProxy(_lookup)

    def push(self, obj):
        rv = getattr(self._local, "stack", None)
        if rv is None:
            self._local.stack = rv = []
        rv.append(obj)
        return rv

    def pop(self):
        stack = getattr(self._local, "stack", None)
        if stack is None:
            return None
        elif len(stack) == 1:
            release_local(self._local)
            return stack[-1]
        else:
            return stack.pop()

    @property
    def top(self):
        try:
            return self._local.stack[-1]
        except (AttributeError, IndexError):
            return None


class LocalManager(object):

    def cleanup(self):
        for local in self.locals:
            release_local(local)

    def make_middleware(self, app):
        def application(environ, start_response):
            return ClosingIterator(app(environ, start_response), self.cleanup)
        return application


@implements_bool
class LocalProxy(object):

    def __init__(self, local, name=None):
        object.__setattr__(self, "_LocalProxy__local", local)
        object.__setattr__(self, "__name__", name)

    def _get_current_object(self):
        if not hasattr(self.__local, "__release_local__"):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError("no object bound to %s" % self.__name__)