Flask上下文以及python__setattr__常见问题

Flask上下文管理

-threading.local对象，用于为每个线程开辟一块空间来保存它独有的值。

-源码（request）

    -情况一：单进程单线程，基于全局变量做。

    -情况二：单进程多线程，threading.local对象。

    -情况三：单进程单线程（多协程），threading.lcoal对象做不到。

-建议：

    -以后不支持协程：就用threading.local对象

    -支持协程：自定义类似threading.local对象

 

线程

通过threading.local()保护线程数据安全

import threading
local_values = threading.local()

'''
local_values = threading.local()就是起到一个锁的作用，每个线程都可以对threading.local对象进行读写，且互相不干扰。
用于为每个线程开辟一块空间来保存它独有的值。
'''
def func(num):
    local_values.name=num
    import time
    time.sleep(1)
    print(local_values.name,threading.current_thread().name)

for i in range(10):
    th = threading.Thread(target=func,args=(i,),name="线程是%s"%i)
    th.start()

 

 

一个简单的自定义方法实现threading.local功能：

线程

import threading
from _thread import get_ident
'''获取线程唯一标示'''
class LOCAL(object):
    '''
    通过自定义的方式实现threadlocal的功能
    初始化的时候定义一个字典以及线程唯一标示
    然后通过set设置k,v,再用get取值
    '''
    def __init__(self):
        self.storage = {}
        self.get_ident = get_ident
    def set(self,k,v):
        ident = self.get_ident()
        origin = self.storage.get(ident)
        if not origin:
            origin = {k:v}
        else:
            origin[k] = v
        self.storage[ident] = origin
    def get(self,k):
        ident = self.get_ident()
        origin = self.storage.get(ident)
        if not origin:
            return  None
        return origin.get(k,None)

local_values = LOCAL()
def task(num):
    local_values.set('name',num)
    import time
    time.sleep(1)
    print(local_values.get('name'), threading.current_thread().name)
for i in range(10):
    th = threading.Thread(target=task,args=(i,),name="线程是%s"%i)
    th.start()

通过安装gevent，用getcurrent的方式获取协程的唯一标示：

以下是实现协程的单独资源管理

import threading
from greenlet import getcurrent as get_ident
'''获取协程唯一标示，需要安装gevent，同时自动安装greenlet，通过
from greenlet import getcurrent 模块判断协程唯一标示,其他代码不变'''
class LOCAL(object):
    '''
    通过自定义的方式实现threadlocal的功能
    初始化的时候定义一个字典以及线程唯一标示
    然后通过set设置k,v,再用get取值
    '''
    def __init__(self):
        self.storage = {}
        self.get_ident = get_ident
    def set(self,k,v):
        ident = self.get_ident()
        origin = self.storage.get(ident)
        if not origin:
            origin = {k:v}
        else:
            origin[k] = v
        self.storage[ident] = origin
    def get(self,k):
        ident = self.get_ident()
        origin = self.storage.get(ident)
        if not origin:
            return  None
        return origin.get(k,None)

local_values = LOCAL()
def task(num):
    local_values.set('name',num)
    import time
    time.sleep(1)
    print(local_values.get('name'), threading.current_thread().name)
for i in range(10):
    th = threading.Thread(target=task,args=(i,),name="线程是%s"%i)
    th.start()

 

 

面向对象知识点补充

关于__setattr__的使用以及常见问题：

#扩展内容，__setattr__
class Foo(object):
    def set(self,k,v):
        pass
    def __setattr__(self, key, value):
        print(key,value)
        pass

obj = Foo()
obj.set('x',123)
obj.x = 123 #用__setattr__比set函数要方便许多

#__setattr__方法常见的坑

class Foo(object):
    def __init__(self):
        self.storage = {}
    def __setattr__(self, key, value):
        self.storage={'k1':'v1'}
        print(key,value)
    def __getattr__(self, item):
        print(item)


obj = Foo()
obj.x = 123
'''
当初始化的时候，self.storage，对象调用storage就会自动执行__setattr__方法，
然后__setattr__方法里面又是对象调用属性，就会再执行setattr，这样就是无限递归了。
为了避免这个问题需要用下面这种方式实现：
'''
class Foo(object):
    def __init__(self):
        object.__setattr__(self,'storage',{})

    def __setattr__(self, key, value):
        self.storage={'k1':'v1'}
        print(key,value)

    def __getattr__(self, item):
        print(item)
        return "sdf"
obj = Foo()
#注意如果obj.x = 123就会触发__setattr__方法，还是会出现递归的问题。

以下为参考源码实现的方式：

#源码的实现方式：
import threading
try:
    from greenlet import getcurrent as get_ident # 协程
except ImportError:
    try:
        from thread import get_ident
    except ImportError:
        from _thread import get_ident # 线程


class Local(object):

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


    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)


local_values = Local()


def task(num):
    local_values.name = num
    import time
    time.sleep(1)
    print(local_values.name, threading.current_thread().name)


for i in range(20):
    th = threading.Thread(target=task, args=(i,),name='线程%s' % i)
    th.start()