线程携程 threading.local的作用

 

from threading import get_ident,Thread
import time
#get_ident()获取当前的线程id  
  
storage = {}
def set(k,v):
    ident = get_ident()
    if ident in storage:
        storage[ident][k] = v
    else:
        storage[ident] = {k:v}

def get(k):
    ident = get_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()

打印结果如下

 

#encoding=utf-8
from threading import local
from threading import Thread

import  time
#实例化一个特殊的对象,
# 他的功能就是给每一个线程过来都给他开辟一个空间
#这就是trading.local的作用
xianglong=local()
def task(arg):
    global xianglong
    #
    xianglong.val=arg
    time.sleep(0.2)
    print(xianglong.val)
for i in range(10):
    t=Thread(target=task,args=(i,))
    t.start()

打印结果

 

 

 

使用携程  类方法来完成

 

try:#尝试优先根据携程来做，没有携程在走线程
    #获取当前携程的唯一标识
    from greenlet import getcurrent as get_ident
except Exception as e:
    #获取当前线程的唯一标识
    from threading import get_ident

from threading import Thread
import time

class Local(object):

    def __init__(self):
    #创建一个全局的storage字典，但是要继承父类的setattr方法，
    #因为如果用自己I的话就会超过最大递归深度，就会报错
        object.__setattr__(self,'storage',{})

    def __setattr__(self, k, v):
        ident = get_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()

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

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