LocalStack和Local对象实现栈的管理

            在最上方找关于get_ident的源码:

            try
            :
        
            from greenlet import getcurrent as get_ident # getcurrent他可以为每一个协程标记一个IDexcept ImportError:
        try:
                from thread import get_ident  #这里我们用的是线程的id
        except ImportError:
                from _thread import get_ident 


上面的源码可以理解为: from threading import get_ident 

            Local的源码:

            class
             Local(object):
        
            __slots__ = ("__storage__", "__ident_func__")                   #就是指明Local可以.这两种方法def__init__(self):
                object.__setattr__(self, "__storage__", {})             #相当于 self.__storage__={}
                object.__setattr__(self, "__ident_func__", get_ident)   #相当于 self.__ident_func__=get_identdef__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__()                             #取到线程id1111
                storage = self.__storage__try:
                        storage[ident][name] = value                      #造出{111:{x1:123}},name=x1except KeyError:
                        storage[ident] = {name: value}          #取走123,当LocalStack()实例化对象过来时setattr方法就维护了111:{‘stack‘:[]} statck是固定值,LoaclStack传过来的def__delattr__(self, name):
                try:
                        del self.__storage__[self.__ident_func__()][name]
                except KeyError:
                        raise AttributeError(name)

当local=Local()时看init
local.x1=123执行__setattr__
local.x1找getattr

这个Local类会建立一个字典:
"""
__storage__ = {
1111:{"stack":[‘陈说‘,‘龙龙‘] }
}
"""

            class
             LocalStack(object):
        
            def
            __init__
            (self):
                self._local = 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):
                rv = getattr(self._local, "stack", None) #self._local.stack 触发Local类的getattr方法,其中self._local是Local的对象,就找Local类中的getattr,Local的getattr返回None# rv = None
                if rv is None:
                       self._local.stack = rv = []       #这句话的意思是rv=[],self._local.stack=[],就是给[]赋两个值,rv和stack共用[],这里会找Local的setattr,name=stack,value=[]
                rv.append(obj)                           #obj就是obj.push(‘成说‘)传过来的陈说,[]==>[‘陈说‘]
                return rv

        def pop(self):
                stack = getattr(self._local, "stack", None)  #取到列表[‘陈说‘,‘龙龙‘]
                if stack is None:
                        return None
                elif len(stack) == 1:   #简单来说就是当你列表中只有一个值时,你来pop,就销毁statck
              #如果del __storage__[1111]里面加上线程id就销毁了这个id包括所对应的值,只剩__storage__ = {},并且返回最后一个列表中的值,具体功能在release_local中实现的                        release_local(self._local)
                        return stack[-1]
                else:
                        return stack.pop()               #删除[‘陈说‘,‘龙龙‘]中的‘龙龙‘,
        @property
        def top(self):
                try:
                        return self._local.stack[-1]     #找Local的getattr,拿到 {1111:{"stack":[‘陈说‘,‘龙龙‘] }}列表中的-1位置的内容.-1位置就是栈顶(后进先出,弹夹)
                except (AttributeError, IndexError):   
                        return None

obj=LocalStack()找init
obj.push(‘陈说‘) 找push方法
obj.push(‘龙龙‘) 找push方法
print(obj.top)找LocalStack()的top

obj.pop找LocalStack()的pop
再obj.pop,就再删除

            总结(要记一记):
①在flask中有个local类，他和threading.local的功能一样，为每个线程开辟空间进行存取数据，内部实现机制:内部维护一个字典__storage__ = {},
然后线程id(或协程id)为key(是为了数据隔离,进程(协程)id之间的数据是隔离开的)后面的value为一个字典(键和值就是看你传的内容)，如：
    __storage__ = {1211:{‘k1‘:123}}
        obj = Local()
        obj.k1 = 123

②在flask中还有一个LocalStack的类，他内部会依赖local对象，local对象负责存储数据，localstack对象用于将local中的值维护成一个栈,
然后进行数据交互.如果没有这个LocalStack类,Local类一样可以使用,但只能存一个字典key:value,而LocalStack类是帮我们把字典变成列表(这样就有了栈的功能)
    __storage__ = {1211:{‘stack‘:[‘k1‘,‘k2‘]}}

    obj= LocalStack()
        obj.push(‘k1‘)
        obj.push(‘k2‘)
        obj.top
        obj.pop()

请求上下文管理:
_request_ctx_stack = LocalStack()          #这个对象要放的内容:request和session封装到一个对象中去,并把对象装到列表中.__storage__ = {
    1111:{‘stack‘:[RequestContext(reqeust,session),]},      #将RequestContext(reqeust,session)对象封装俩值再放到列表中
        1123:{‘stack‘:[RequestContext(reqeust,session),]},
}


应用上下文管理:
_app_ctx_stack = LocalStack()              #这个对象要放的内容:app和g封装到一个对象中去,并把对象放到列表中.__storage__ = {
    1111:{‘stack‘:[AppContenxt(app,g),]}                     #app就是Flask(__name__)实例化的对象
        1123:{‘stack‘:[AppContenxt(app,g),]},                #将AppContenxt(app,g)对象封装俩值再放到列表中
}