首先贴出官方文档地址：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.topLocalStack，与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__)
