本文首发于微信公众号：战渣渣
欢迎大家关注。
关联知识
WEB开发——Python WSGI协议详解
Flask进击篇（1）——Flask运行流程
背景
在Flask中可直接导入from flask import request, current_app, g并直接使用，那Flask是如何保证这个request对象就是这个请求对象呢？
Flask官方中有提到使用的是本地线程对象，这篇文章就来揭示其原理
Flask线程间上下文安全
Falsk完成线程安全的原理，是在启动之后进程里维护request栈和app栈，栈是通过线程ID来保证每个请求的线程安全。
实现主要依赖三个类Local，LocalStack和LocalProxy，下面看一下具体的实现原理
三个类构建本地数据
1. Local
先看Local的源码，实质并不是Flask中定义的，而是Flask依赖的werkzeug库所定义。
# werkzeug\local.py
# get_ident获取线程和协程的唯一标识
try:
from greenlet import getcurrent as get_ident
except ImportError:
try:
from thread import get_ident
except ImportError:
from _thread import get_ident
# 实际的Local类
class Local(object):
__slots__ = ('__storage__', '__ident_func__')
def __init__(self):
object.__setattr__(self, '__storage__', {})
object.__setattr__(self, '__ident_func__', get_ident)
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}
可以看到其定义的两个属性__storage__， __ident_func__以及三个方法__getattr__，__setattr__，__release_local__。
属性__storage__是多层级字典，第一层key是隐含的线程ID或者协程ID，第二层的key是实际使用的关键字
属性__ident_func__可以看到是get_ident函数，get_ident函数要么是通过thread库获取当前执行单元的线程ID，要么是通过greenlet库获取当前执行协程的协程ID。
另外可以看到Local这个类的三个方法，实质是通过重写Python内置函数__setattr__和__getattr__来实现线程或者协程间数据隔离
-
获取local某属性时
如：local.age实质触发的是__getattr__方法
先获取到当前线程ID——__ident_func__函数获取，然后在__storage__字典中找到线程ident对应的结果集
从获取到的结果中再查找age属性
-
设置local某属性时
如：local.age = 12 实际触发的是__setattr__方法
先获取到当前线程ID——__ident_func__函数获取，然后在__storage__字典设置相应的属性字典集
另一个__release_local__方法就是将相应的线程数据删除。
画个简图比较起来更直观一些。
主线程中生成一个对象local=Local()，三个线程中进行相同的操作local.no=每个线程对应的数。为每个线程都开辟一个存储，所以谁来取或者存就找到自己对应中的位置，虽然取得key都一样，但是每次存取都是只关于自己的值。
2. LocalStack
LocalStack也是定义在Flask所依赖的werkzeug库，从字面意思来理解，它就是Local的堆栈操作，看一下源码如何定义。
class LocalStack(object):
def __init__(self):
self._local = Local()
def __release_local__(self):
self._local.__release_local__()
def _get__ident_func__(self):
return self._local.__ident_func__
def _set__ident_func__(self, value):
object.__setattr__(self._local, "__ident_func__", value)
__ident_func__ = property(_get__ident_func__, _set__ident_func__)
del _get__ident_func__, _set__ident_func__
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):
"""Pushes a new item to the stack"""
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
LocalStack实质就是围绕着Local来进行操作，根据上面我们读完Local的源码可以看到，
- LocalStack定义了一个Local对象
- 给这个对象设置了一个stack属性，且这个属性是一个列表
- LocalStack中定义了对这个列表进行压栈，出栈等方法
- 给类中的Local对象提供了自定义ident_func的方法
3. LocalProxy
LocalProxy字面意思就是做一个Local的代理，我们先从一个request的定义来看LocalProxy的用法，然后结合源码来看LocalProxy到底是用来做什么？
# venv/Lib/site-packages/werkzeug/local.py
@implements_bool
class LocalProxy(object):
__slots__ = ("__local", "__dict__", "__name__", "__wrapped__")
def __init__(self, local, name=None):
object.__setattr__(self, "_LocalProxy__local", local)
object.__setattr__(self, "__name__", name)
if callable(local) and not hasattr(local, "__release_local__"):
# "local" is a callable that is not an instance of Local or
# LocalManager: mark it as a wrapped function.
object.__setattr__(self, "__wrapped__", local)
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__)
def __getattr__(self, name):
if name == "__members__":
return dir(self._get_current_object())
return getattr(self._get_current_object(), name)
__setattr__ = lambda x, n, v: setattr(x._get_current_object(), n, v)
类中稍微有些难理解的就是关于object.__setattr__(self, "_LocalProxy__local", local)的作用，实际就是给self设置一个__local属性。这是Python类中关于私有变量的定义。可以看Python的官方定义python私有变量。
可以看到这个类将所有Python类所内置的方法都进行重写，重写后所有的操作都是基于类中所定义的_get_current_object方法返回的对象进行操作。
而这个方法中返回值就是初始化时所给定的local对象执行返回的结果。如果创建时指定的不是Local对象，则直接执行此方法。如果给定的是Local对象，则根据类名查找对应的对象。
现在这个比较抽象，这个代理到底是做的什么？ 我们结合Flask定义全局的request对象来看。假如我们想获取请求的方法是什么，那我们使用的就是request.method。
下面是request定义的源码
# flask/globals.py
def _lookup_req_object(name):
top = _request_ctx_stack.top
if top is None:
raise RuntimeError(_request_ctx_err_msg)
return getattr(top, name)
request = LocalProxy(partial(_lookup_req_object, "request"))
- 根据LocalProxy的源码中重写的__getattr__方法，先执行_get_current_object方法获取到对象，然后再获取返回对象method属性。
- 创建LocalProxy时传递的函数是_lookup_req_object的偏函数，实际就是_lookup_req_object且name=request
- 再LocalProxy中__local就是一个函数，所以在执行_get_current_object就是执行_lookup_req_object且name=request返回的值，然后再取其method属性
- 此时再执行_lookup_req_object函数，从_request_ctx_stack获取top的request
使用Proxy可以简单快捷的使用request.method获取相应的值，其核心就是每次获取时都会执行对应的函数，而函数中每次返回的值都是线程安全。保证数据正确且优雅。 否则我们每次都去执行一个函数来获取其值，然后再取其属性。
