小伙伴们，到今天 threading 模块彻底讲完。现在全面总结 threading 模块

1、threading模块有自己的方法

详细点击【threading模块的方法】

threading 模块：较低级的模块 _thread 基础上进行的封装。

import threading as T

t1 = T.current_thread().name  # 当前运行线程的名称
t2 = T.main_thread().name  # 主线程的名称
t3 = T.enumerate()  # 线程列表
t4 = T.active_count()  # 线程活动的数量

# 以下两个方法并不是设置一次，所有线程启动都运行，所以没什么用
T.settrace(func)  # 为每个线程设置跟踪函数，启动前运行，没什么用途
T.profile(func)  # 为每个线程设置一个配置文件函数，启动前运行，没什么用途

2、Tread 类

详细点击【线程之一：线程的创建、启动及运行方式】

线程的创建和启动（两种方法）

• 实例化 Thread 类的方式

t = Thread(target=None, name=None, args=(), kwargs=None, daemon=None)

• 继承 Thread 类，重写 run() 方法的方式

from threading import Thread
# 定义线程类
class Person(Thread):
    def __init__(self):
        super(Person, self).__init__()
    def run(self):
        print('线程启动后运行 run 函数')

运行方式有四种（daemon、join组合）

• 等子线程结束，主线程再继续运行 , join()
• 等子线程2秒，主线程再继续运行 , join(timeout=2)
• 不等子线程，跟随主线程结束 , daemon=True
• 等子线程2秒，跟随主线程结束 , daemon=True; join(timeout=2)

3、线程锁

详细点击【四种锁-线程安全通信的基础】

• Lock 类：一把大锁保护一个代码块
• RLock 类：大锁可以套小锁保护多个代码块
• Condition 类：Lock 类或 RLock 类的二次封装，加入了等待和唤醒功能。 默认是递归锁
• Semaphore 类：Condition 类的二次封装，加入了同时执行线程的数量限制

定义一个锁对象
with 锁对象:
    代码块 ...

4、线程间通信

详细点击【线程间通信，由锁实现的模块，推荐两种】

• Event 类：Condition 类的二次封装，改变一个标识的真假

from threading import Event  # 这个事件比较简单，就是一个标识

event = Event()  # 定义一个事件对象，
event.is_set()  # 返回：False  解读：返回内部标识，这个标识初始时为 false
event.set()   # 把内部标识设置为 True
event.clear()  # 把内部标识设置为 False
event.wait()  # 阻塞线程，直到内部标识变成 True。可以设置超时

• queue模块：Condition 类的二次封装，线程间消息传递

from queue import Queue
que = Queue()

que.empty()  # 队列为空，返回 True，否则返回 False
que.full()  # 队列设置长度时，满了返回 True，否则 False
que.qsize()  # 返回队列的长度

# 写入队列4种方式
que.put(1)
# 解读：1、等价于 que.put(1,block=True,timeout=None)
# 2、阻塞写入：队列满了阻塞，一直等到不满的时候再写入，不报错
que.put(1,timeout=1)
# 解读：1、等价于 que.put(1,block=True,timeout=1)
# 2、阻塞写入：队列满了阻塞，阻塞超过1秒，报错 queue.Full
que.put(1,block=False)  # 非阻塞时 timeout 参数无效
# 解读：1、等价于 que.put(1,block=False,timeout=None)
# 2、非阻塞写入：队列满了，立即报错 queue.Full
que.put_nowait()
# 解读：1、等价于 que.put(1,block=False)
# 2、非阻塞写入：队列满了，立即报错 queue.Full

# 读取队列4种方式
que.get()  # 获取队列数据
# 解读：1、等价于 que.get(block=True,timeout=None)
# 2、阻塞获取：队列空了阻塞，一直等到不为空时再读取，不报错
que.get(timeout=1)
# 解读：1、等价于 que.get(block=True,timeout=1)
# 2、阻塞获取：队列空了阻塞，阻塞超过1秒，报错 _queue.Empty
que.get(block=False)  # 非阻塞时 timeout 参数无效
# 解读：1、等价于 que.get(block=False,timeout=None)
# 2、非阻塞获取：队列空了，立即报错 _queue.Empty
que.get_nowait()
# 解读：等价于 que.get(block=False)
# 2、非阻塞获取：队列空了，立即报错 _queue.Empty

# jion 和 task_done 一般配合使用，看生产者和消费者模型示例
que.join()
# 解读：1、一般用于生产者线程，put 后阻塞线程，直到 task_done 解除阻塞，生产者线程才会继续运行
# 2、必须配合消费者线程 task_done 解除阻塞，否则生产者线程会一直阻塞下去
que.task_done()
# 解读：1、用于消费者线程，get 后使用 task_done，直到队列为空时，解除阻塞
# 2、一个消费者线程 task_done 一次，只能解除一个生产者线程的 join 阻塞

queue 模块，详细点击【python线程之七：线程间通信queue，最全、最明白阐述】

5、Timer 类：

详细点击【定时器（Timer），非阻塞】

• 继承 Thread 类，重写 run 函数，加入了时间延迟功能

# 定时器的定义及启动
from threading import Timer
def work():
    print('工作中')
t = Timer(2, work)  # 启动后，等待2秒，再执行work 函数
t.start()
# 打印返回：工作中

6、local 类：

详细点击【本地对象（local）】

• 线程本地对象，较低级的模块 _thread 基础上进行的封装。

from threading import local
l = local()  # 创建一个本地对象

# 设置属性（随便设置，想添加什么就添加什么）
l.name = 'jack'  # 解读：给对象添加 name 属性
l.age = 30  # 解读：给对象添加 age 属性

# 读取属性
print(l.name)  # 返回：jack   解读：使用 name 属性
print(l.__dict__) # 返回：{'name': 'jack', 'age': 30}   解读：返回所有属性，字典

# 删除属性
del l.age  # 解读：删除 age 属性
print(l.__dict__)  # 返回：{'name': 'jack'}

7、线程停止方式

详细点击【python线程之八：线程停止的3种方式，5个实例】

• 正常停止线程：通过标志全局变量、Event 类
• 强制停止线程：通过 C 语言接口

8、生产者、消费者模式

详细点击【python线程之九：生产者消费者3种方式，2个线程1个协程】

• Condition 类实现
• queue 模块实现
• yield 协成函数实现

至此，python 线程全部总结完成。如有疑问，欢迎讨论