Flask补充--threading.local对象

目录

• Local
  • 局部变量
  • 全局变量
  • 使用threading.local()
• 自定义threading.local
  • 函数版
  • 面向对象版
  • 通过setattr和getattr实现
  • 每个对象有自己的存储空间（字典）

在Flask请求上下文中，我们发现Flask中current_app, g这两个对象以及request,session这两个对象，在整个Flask生命周期中，都只是一个对象，那当请求过来的时候，是怎么区分是哪个用户的呢？

current_app = LocalProxy(_find_app)
request = LocalProxy(partial(_lookup_req_object, 'request'))
session = LocalProxy(partial(_lookup_req_object, 'session'))
g = LocalProxy(partial(_lookup_app_object, 'g'))

这里面主要用到了一个线程里面的Local对象以及偏函数partial

Local

在使用threading.local()之前，先了解一下局部变量和全局变量。

局部变量

import threading
import time

def foo():
    x = 0
    for i in range(100):
        time.sleep(0.0001)
        x += 1

    print(threading.current_thread(), x)


for i in range(5):
    threading.Thread(target=foo).start()
    
"""
运行结果：
<Thread(Thread-5, started 21732)> 100
<Thread(Thread-1, started 13300)> 100
<Thread(Thread-4, started 1568)> 100
<Thread(Thread-2, started 19864)> 100
<Thread(Thread-3, started 23984)> 100
"""

上面例子使用多线程，每个子线程完成不同的计算任务，x是局部变量。

每个子线程都要压栈，每个栈是独立的空间。每次压栈，局部变量x的作用域地址是不同的(线程独享)，计算结果互不干扰。

全局变量

import threading
import time

x = 0

def foo():
    global x
    x = 0
    for i in range(100):
        time.sleep(0.0001)
        x += 1

    print(threading.current_thread(), x)


for i in range(5):
    threading.Thread(target=foo).start()
    
"""
运行结果：
<Thread(Thread-1, started 19492)> 491
<Thread(Thread-3, started 22692)> 497
<Thread(Thread-5, started 24344)> 498
<Thread(Thread-2, started 24428)> 499
<Thread(Thread-4, started 19000)> 500
"""

上面例子中当主线程中x是全局变量时，就变成了公共资源(也就是同一个对象)，每个子线程互相干扰，最终导致错误的计算结果。

Python提供了 threading.local 类，将这个类实例化得到一个全局对象，但是不同的线程使用这个对象存储的数据其它线程不可见(本质上就是不同的线程使用这个对象时为其创建一个独立的字典)。

使用threading.local()

import threading
import time

loc = threading.local()

def foo():
    loc.x = 0
    for i in range(100):
        time.sleep(0.0001)
        loc.x += 1

    print(threading.current_thread(), loc.x)


for i in range(5):
    threading.Thread(target=foo).start()
    
"""
运行结果：
<Thread(Thread-1, started 20008)> 100
<Thread(Thread-2, started 23644)> 100
<Thread(Thread-5, started 10396)> 100
<Thread(Thread-4, started 22280)> 100
<Thread(Thread-3, started 19980)> 100
"""

每个子线程使用全局对象loc，但每个线程定义的属性loc.x是该线程独有的。

举一个错误的例子:，主线程中使用threading.local定义本地变量x，x在主线程中是独有的，子线程中就访问不到主线程的x的属性。

import threading
 
X='abc'
ctx=threading.local()
ctx.x=123 #主线程中定义x本地属性
print(ctx,type(ctx),ctx.x)
 
def work():
    print(X)
    print(ctx)
    print(ctx.x) #子线程访问不到
    print('Good job')
 
threading.Thread(target=work).start()

"""
运行结果：
<_thread._local object at 0x000001B22BBAB780> <class '_thread._local'> 123
abc
<_thread._local object at 0x000001B22BBAB780>
Exception in thread Thread-1:
Traceback (most recent call last):
  File "E:/Python学习笔记/flask/123.py", line 13, in work
    print(ctx.x)  # 子线程访问不到
AttributeError: '_thread._local' object has no attribute 'x'
"""

ctx全局对象对主线程和子线程都是可以使用的，主线程定义了属性x，但子线程在尝试访问属性x时，就相当于访问自己线程内的属性x，而自己线程并没有定义，就会抛出AttributeError异常：'_thread._local' object has no attribute 'x'。

自定义threading.local

函数版

from threading import get_ident, Thread
import time

# 定义一个全局字典
storage = {}

def set(k, v):
    ident = get_ident()
    # print(ident)
    if ident in storage:
        storage[ident][k] = v
    else:
        storage[ident] = {k: v}

def get(k):
    ident = get_ident()
    # print(ident)
    return storage[ident][k]

def task(arg):
    set('val', arg)
    v = get('val')
    # print(v)

for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

print(storage) 
"""
{
    20552: {'val': 0}, 
    18496: {'val': 1}, 
    24476: {'val': 2}, 
    18700: {'val': 3}, 
    23740: {'val': 4}, 
    22160: {'val': 5}, 
    23896: {'val': 6}, 
    19204: {'val': 7}, 
    19028: {'val': 8}, 
    17972: {'val': 9}
}
"""

面向对象版

from threading import get_ident,Thread
import time

class Local(object):
    # 定义一个类字典
    storage = {}
    
    def set(self, k, v):
        ident = get_ident()
        if ident in Local.storage:
            Local.storage[ident][k] = v
        else:
            Local.storage[ident] = {k: v}
            
    def get(self, k):
        ident = get_ident()
        return Local.storage[ident][k]
    
obj = Local()

def task(arg):
    obj.set('val',arg) 
    v = obj.get('val')
    print(v)
    
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()
    
print(Local.storage)
"""
{
	19296: {'val': 0}, 
	20436: {'val': 1}, 
	8240: {'val': 2}, 
	19668: {'val': 3}, 
	16932: {'val': 4}
}
"""

通过setattr和getattr实现

from threading import get_ident,Thread
import time

class Local(object):
    storage = {}
    
    def __setattr__(self, k, v):
        ident = get_ident()
        if ident in Local.storage:
            Local.storage[ident][k] = v
        else:
            Local.storage[ident] = {k: v}
            
    def __getattr__(self, k):
        ident = get_ident()
        return Local.storage[ident][k]
    
obj = Local()
def task(arg):
    obj.val = arg
    print(obj.val)
    
for i in range(10):
    t = Thread(target=task,args=(i,))
    t.start()

每个对象有自己的存储空间（字典）

from threading import get_ident, Thread
import time


class Local(object):

    def __init__(self):
        object.__setattr__(self, 'storage', {})
        # print(1, self.__dict__)
        # self.aaa = {}
        # print(self.__dict__)

    def __setattr__(self, k, v):
        # print(k, v, '>>>')
        ident = get_ident()
        # print(ident)
        if ident in self.storage:
            self.storage[ident][k] = v
        else:
            self.storage[ident] = {k: v}

    def __getattr__(self, k):
        ident = get_ident()
        return self.storage[ident][k]


obj = Local()
# print(2, obj.__dict__)


def task(arg):
    obj.val = arg
    obj.xxx = arg
    print(obj.val)
    # print(obj.__dict__)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()