资讯专栏INFORMATION COLUMN

Werkzeug Local与LocalProxy等浅析

The question / 1621人阅读

摘要:线程局部变量,也就是每个线程的私有变量,具有线程隔离性。按我们正常的理解,应该是每一个请求对应一个处理线程。在中,除了线程之外,还有个叫协程的东东,这里不提进程。配合会确保不管是协程还是线程,只要当前请求处理完成之后清除中对应的内容。

首先贴出官方文档地址: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__)

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/44323.html

相关文章

  • flask 源码解析:上下文

    摘要:但是这些对象和全局变量不同的是它们必须是动态的,因为在多线程或者多协程的情况下,每个线程或者协程获取的都是自己独特的对象,不会互相干扰。中有两种上下文和。就是实现了类似的效果多线程或者多协程情况下全局变量的隔离效果。 这是 flask 源码解析系列文章的其中一篇,本系列所有文章列表: flask 源码解析:简介 flask 源码解析:应用启动流程 flask 源码解析:路由 flas...

    Labradors 评论0 收藏0
  • 深入 Flask 源码理解 Context

    摘要:主要的作用是将维护的字典中键为对应的值定义为。如果没有,则会将当前到中,同时将加入列表中否则添加。注意清理之后的动作。上述代码涉及到,它强调必须是一个可调用对象。后期的工作之一是了解。这仅仅是我的个人理解。实际上这是解决多个实例运行的问题。 Flask 中的上下文对象 知乎问题 编程中什么是「Context(上下文)」 已经能够简单地说明什么是 Context,它是一个程序需要的外部对...

    ninefive 评论0 收藏0
  • Flask中的请求上下文和应用上下文

    摘要:并且栈顶的元素都是的请求上下文和应用上下文之后,我们再在这个环境中嵌套的应用上下文。这时查看两个栈的内容,发现两个栈中只有的请求的请求上下文对象和应用上下文对象。而等一直指向栈顶的请求上下文对象,分别引用请求上下文的和。 在Flask中处理请求时,应用会生成一个请求上下文对象。整个请求的处理过程,都会在这个上下文对象中进行。这保证了请求的处理过程不被干扰。处理请求的具体代码如下: de...

    sourcenode 评论0 收藏0
  • flask 核心 之 应用上下文 及 请求上下文

    摘要:的上下文对象有两种上下文,分别是请求上下文请求的对象,封装了请求的内容,生命周期请求处理完就结束了根据请求中的,重新载入该访问者相关的会话信息应用上下文处理请求时用作临时存储的对象。 Werkzeugs 是 Flask 的底层WSGI库。 什么是WSGI? showImg(https://s1.ax1x.com/2018/11/13/iOqdKS.jpg); 一段简单的app: def...

    tinna 评论0 收藏0
  • 深入理解Python中的ThreadLocal变量(下)

    摘要:具体怎么实现的呢,思想其实特别简单,我们在深入理解中的变量上一文的最后有提起过,就是创建一个全局字典,然后将线程或者协程标识符作为,相应线程或协程的局部数据作为。 在上篇我们看到了 ThreadLocal 变量的简单使用,中篇对python中 ThreadLocal 的实现进行了分析,但故事还没有结束。本篇我们一起来看下Werkzeug中ThreadLocal的设计。 Werkzeug...

    dadong 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<