python语言线程标准库threading.local解读总结

本段源码可以学习的地方:

1. 考虑到效率问题,可以通过上下文的机制,在属性被访问的时候临时构建;

2. 可以重写一些魔术方法,比如 __new__ 方法,在调用 object.__new__(cls) 前后进行属性的一些小设置;

3. 在本库中使用的重写魔术方法,上下文这两种基础之上,我们可以想到函数装饰器,类装饰器,异常捕获,以及两种上下文的结构;

灵活运用这些手法,可以让我们在代码架构上更上一层,能够更加省时省力。

from weakref import ref # ref用在了构造大字典元素元组的第一个位置即 (ref(Thread), 线程字典)
from contextlib import contextmanager # 上下文管理,用来确保__dict__属性的存在
from threading import current_thread, RLock
__all__ = ["local"]

class _localimpl: # local()._local__impl = _localimpl() # local()实例的属性_local__impl就是这个类的实例
  """一个管理线程字典的类"""
  __slots__ = 'key', 'dicts', 'localargs', 'locallock', '__weakref__' # _local__impl有这么多属性

  def __init__(self):
    # 这个self.key是用在线程对象的字典中的key
    # self.key使用的一个字符串,这样既能运行的快,
    # 但是通过'_threading_local._localimpl.' + str(id(self)也能保证不会冲突别的属性

    self.key = '_threading_local._localimpl.' + str(id(self))
    #
    self.dicts = {} # 大字典
    # 格式是: { id(线程1):(ref(Thread), 线程1自身的字典), id(线程2):(ref(Thread), 线程2自身的字典), ... }

  def get_dict(self): # 从大字典中拿(ref(Thread), 线程字典), 然后取线程字典
    thread = current_thread()
    return self.dicts[id(thread)][1]

  def create_dict(self): # 为当前线程创建一个线程字典,就是(ref(Thread), 线程字典)[1],即元组的第二部分
    localdict = {}
    key = self.key # key使用'_threading_local._localimpl.' + str(id(self)
    thread = current_thread() # 当前线程
    idt = id(thread) # 当前线程的id
    def local_deleted(_, key=key): # 这个函数不看 pass
      # When the localimpl is deleted, remove the thread attribute.
      thread = wrthread()
      if thread is not None:
        del thread.__dict__[key]
    def thread_deleted(_, idt=idt): # 这个函数不看 pass
      # When the thread is deleted, remove the local dict.
      # Note that this is suboptimal if the thread object gets
      # caught in a reference loop. We would like to be called
      # as soon as the OS-level thread ends instead.
      local = wrlocal()
      if local is not None:
        dct = local.dicts.pop(idt)
    wrlocal = ref(self, local_deleted)
    wrthread = ref(thread, thread_deleted) # 大字典中每一个线程对应的元素的第一个位置: (ref(Thread), 小字典)
    thread.__dict__[key] = wrlocal
    self.dicts[idt] = wrthread, localdict # 在大字典中构造: id(thread) : (ref(Thread), 小字典)
    return localdict

@contextmanager
def _patch(self):
  impl = object.__getattribute__(self, '_local__impl') # 此时的self是local(), 拿local()._local__impl
  try:
    dct = impl.get_dict()  # 然后从拿到的local()._local__impl调用线程字典管理类的local()._local__impl.get_dict()方法
                # 从20行到22这个get_dict()方法的定义可以看出来,拿不到会报KeyError的

  except KeyError: # 如果拿不到报 KeyError之后捕捉
    dct = impl.create_dict() # 然后再通过线程字典管理类临时创建一个
    args, kw = impl.localargs # 这个时候把拿到
    self.__init__(*args, **kw)
  with impl.locallock: # 通过上下文的方式上锁
    object.__setattr__(self, '__dict__', dct) # 给local() 实例增加__dict__属性,这个属性指向大字典中value元组的第二个元素,即线程小字典
    yield # 到目前为止,local()类的两个属性都构造完成

class local: # local类
  __slots__ = '_local__impl', '__dict__' # local类有两个属性可以访问

  def __new__(cls, *args, **kw):
    if (args or kw) and (cls.__init__ is object.__init__): # pass不看
      raise TypeError("Initialization arguments are not supported")
    self = object.__new__(cls) # pass不看
    impl = _localimpl() # _local_impl属性对应的是_localimpl类的实例
    impl.localargs = (args, kw) # _local_impl属性即_localimpl类的实例 的 localargs属性是一个元组
    impl.locallock = RLock() # pass 不看
    object.__setattr__(self, '_local__impl', impl)
    # 把_local__impl 增加给local(), 所以:local()._local__impl is ipml 即 _localimp()

    # __slots__规定了local()有两个属性,这里已经设置了一个_local__impl;
    # 第二个属性__dict__当我们以后在访问的时候使用上下文进行临时增加,比如第85行

    impl.create_dict() # 就是local._local__impl.create_dict()
    return self # 返回这个配置好_local__impl属性的local()实例

  def __getattribute__(self, name): # 当我们取local()的属性时
    with _patch(self): # 会通过上下文先把数据准备好
      return object.__getattribute__(self, name) # 在准备好的数据中去拿要拿的属性name

  def __setattr__(self, name, value):
    if name == '__dict__': # 这个判断语句是控制local()实例的__dict__属性只能读不能被替换
      raise AttributeError(
        "%r object attribute '__dict__' is read-only"
        % self.__class__.__name__)
    with _patch(self): # 同理, 通过上下文先把__dict__构造好
      return object.__setattr__(self, name, value) # 然后调用基类的方法设置属性

  def __delattr__(self, name): # 删除属性,同理,和__setattr__手法相似
    if name == '__dict__':  # 这个判断语句是控制local()实例的__dict__属性只能读不能被替换
      raise AttributeError(
        "%r object attribute '__dict__' is read-only"
        % self.__class__.__name__)
    with _patch(self): # 同理, 通过上下文先把__dict__构造好
      return object.__delattr__(self, name)

# 整体架构图:
'''

                                        / —— key 属性
                                       / —— dicts 属性, 格式{id(Thread):(ref(Thread), 线程小字典)}
            ———— : _local__impl属性  ---------- 是_local类的实例                           |
           /                             —— 其他属性...                  |
           /             /—————————————————————————————————————————————————————————————————————————————————/
  创建一个local实例              /
           \            /
           \           /
            ———— : __dict__属性 -------- 对应的是_local__impl属性的dicts 中的线程小字典

'''

以上就是本次介绍的全部知识点内容,感谢大家的学习和对我们的支持。

(0)

相关推荐

  • python语言线程标准库threading.local解读总结

    本段源码可以学习的地方: 1. 考虑到效率问题,可以通过上下文的机制,在属性被访问的时候临时构建: 2. 可以重写一些魔术方法,比如 __new__ 方法,在调用 object.__new__(cls) 前后进行属性的一些小设置: 3. 在本库中使用的重写魔术方法,上下文这两种基础之上,我们可以想到函数装饰器,类装饰器,异常捕获,以及两种上下文的结构: 灵活运用这些手法,可以让我们在代码架构上更上一层,能够更加省时省力. from weakref import ref # ref用在了构造大字典

  • 快速掌握Go 语言 HTTP 标准库的实现方法

    目录 HTTP client Client 结构体 初始化请求 NewRequest 初始化请求 Request 准备 http 发送请求 Transport 获取空闲连接 queueForIdleConn 建立连接 queueForDial 等待响应 http server 监听 处理请求 Reference 本篇文章来分析一下 Go 语言 HTTP 标准库是如何实现的. 本文使用的go的源码1.15.7 基于HTTP构建的服务标准模型包括两个端,客户端(Client)和服务端(Server)

  • python进阶collections标准库使用示例详解

    目录 前言 namedtuple namedtuple的由来 namedtuple的格式 namedtuple声明以及实例化 namedtuple的方法和属性 OrderedDict popitem(last=True) move_to_end(key, last=True) 支持reversed 相等测试敏感 defaultdict 小例子1 小例子2 小例子3 Counter对象 创建方式 elements() most_common([n]) 应用场景 deque([iterable[,

  • Python新手学习标准库模块命名

    与Python标准库模块命名冲突 Python的一个优秀的地方在于它提供了丰富的库模块.但是这样的结果是,如果你不下意识的避免,很容易你会遇到你自己的模块的名字与某个随Python附带的标准库的名字冲突的情况(比如,你的代码中可能有一个叫做email.py的模块,它就会与标准库中同名的模块冲突). 这会导致一些很粗糙的问题,例如当你想加载某个库,这个库需要加载Python标准库里的某个模块,结果呢,因为你有一个与标准库里的模块同名的模块,这个包错误的将你的模块加载了进去,而不是加载Python标

  • Python基础之标准库和常用的第三方库案例教程

    Python基础:标准库和常用的第三方库 Python的标准库有: 名称 作用 datetime 为日期和时间处理同时提供了简单和复杂的方法. zlib 直接支持通用的数据打包和压缩格式:zlib,gzip,bz2,zipfile,以及 tarfile. random 提供了生成随机数的工具. math 为浮点运算提供了对底层C函数库的访问. sys 工具脚本经常调用命令行参数.这些命令行参数以链表形式存储于 sys 模块的 argv 变量. glob 提供了一个函数用于从目录通配符搜索中生成文

  • Go 语言 JSON 标准库的使用

    目录 序列化 1. 结构体序列化 2. 字典序列化 3. 切片序列化 反序列化 1. 明确知道 JSON 格式 2. 无法确定 JSON 格式 Go 语言中的 encoding/json 库提供了复杂的将 Go 中各种类型与JSON格式之间转换的功能, 我们主要使用以下几个功能: 将一个切片.结构体或字典序列化成 JSON 格式的字符串[字节流]. 将一个 JSON 格式的字符串[字节流]反序列化成一个切片.结构体或字典. 序列化 序列化使用 json 库中的Marshal函数: func Ma

  • python深度学习标准库使用argparse调参

    目录 前言 使用步骤: 常见规则 使用config文件传入超参数 argparse中action的可选参数store_true 前言 argparse是深度学习项目调参时常用的python标准库,使用argparse后,我们在命令行输入的参数就可以以这种形式python filename.py --lr 1e-4 --batch_size 32来完成对常见超参数的设置.,一般使用时可以归纳为以下三个步骤 使用步骤: 创建ArgumentParser()对象 调用add_argument()方法添

  • 一文详解Go语言fmt标准库的常用占位符使用

    目录 占位符 占位符使用示例 占位符 通过占位符,可以指定格式进行输入或输出,以下为 fmt 标准库里的占位符: 普通占位符 占位符 描述 举例 结果 %v 默认格式的值 fmt.Printf("%v", User{Name: "小明", Age: 18}) {小明 18} %+v 如果打印的是结构体,额外打印字段名 fmt.Printf("%+v", User{Name: "小明", Age: 18}) {Name:小明 A

  • 一文带你了解Go语言fmt标准库输入函数的使用 原创

    目录 fmt 输入函数 Fscan.Fscanf.Fscanln Fscan Fscanf Fscanln Scan.Scanf.Scanln Scan Scanf Scanln Sscan.Sscanf.Sscanln 小结 fmt 输入函数 函数 描述 Fscan(r io.Reader, a ...any) (n int, err error) 从 r 中读取内容,以空格或换行符为分隔符,按顺序依次赋值给不同参数 Fscanf(r io.Reader, format string, a .

  • python中的标准库html

    目录 python之标准库html __init__.py文件提供两个函数: html库中的 entities 模块 html库中的 parser 模块 python之标准库html html库是用于解析HTML的一个工具,是python自带的标准库之一.html库位置: __init__.py文件提供两个函数: __all__ = ['escape', 'unescape'] 介绍 escape 和 unescape: escape(s, quote=True) #用来将特殊字符进行转义成实体

随机推荐