Week 19
本周学习主要内容包括多线程、线程同步、GIL
进程（process）和线程（thread）
在实现了线程的操作系统中，线程是操作系统能够进行运算调度的最小单位，是进程中的实际运作单位。一个程序的执行实例就是一个进程。
进程（process）的前身是作业（job），和job一样每个进程都是隔离的，进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。
进程和程序的关系：
程序是源代码编译后的文件，这些文件存放在磁盘上，当程序被操作系统加载到内存中就是进程；进程中存放着指令和数据（资源），也是线程的容器。
Linux中进程有父、子进程，Windows中是平级关系。
线程（thread）也被称为轻量级进程（Lightweight Process，LWP）是程序执行流的最小单元。一个标准的线程由线程ID，当前指令指针（PC）、寄存器集合和堆、栈组成。
在许多系统中，创建一个线程比创建一个进程块10-100倍（但并不意味着线程比进程好，二者没有可比性，要按需求建立！！！！）
理解
- 每个进程都认为自己独占所有的计算机硬件资源。
- 进程相当于独立的国家，进程间不可以随便共享数据。
- 线程相当于省份，同一个进程内的线程可以共享该进程的资源，每一个线程拥有自己独立的堆栈。
线程的状态
| 状态 | 含义 |
|---|---|
| 就绪（Ready） | 线程能够运行，但在等待被调度，可能线程刚创建启动，或刚刚从阻塞中恢复，或者被其他线程抢占 |
| 运行（Running） | 线程正在运行 |
| 阻塞（Blocked） | 线程等待外部事件发生而无法运行，如I/O操作 |
| 终止（Terminated） | 线程完成，或退出，或被取消（总之不能继续运行） |
Python中的线程开发
- Python的线程开发使用标准库threading
- 进程靠线程执行代码，至少有一个主线程，其他线程是工作线程
- 主线程是第一个启动的线程
- 父子线程：如果线程A中启动了一个线程B，A就是B的父线程，B就是A的子线程
Python中的进程和线程
- 运行程序会启动一个解释器进程，线程共享一个解释器进程
- 解释器进程实际是一个虚拟机，还要再进行翻译过程（编译为一个本地可以运行的二进制文件）
Thread类
| 参数名 | 含义 |
|---|---|
| target | 线程调用的对象，就是目标函数 |
| name | 为线程起个名字 |
| args | 为目标函数传递参数，元组 |
| kwargs | 为目标函数关键字传参，字典 |
线程创建
import threading
def worker(): #工作线程
print("I'm working") #调度worker函数执行里面的代码，内部代码会被翻译成机器指令
pass
print("Finished")
t = threading.Thread(target=worker,) #t是一个线程对象，target=函数，后面传参，该线程是主线程，用于调度
#此步骤创建一个线程对象，此线程未运行
t.start() #启动运行一个线程
线程启动
import threading
import time
def worker():
# while True:
for i in range(10):
time.sleep(1)
print("I'm working")
pass
print("Finished")
t = threading.Thread(target=worker,) #创建一个线程对象，此线程未运行。主线程
t.start() #启动运行一个线程
- 通过threading.Thread创建一个线程对象，target是目标函数，可以使用name为线程指定名称。但线程没有启动是需要调用start方法
- 线程之所以执行函数，是因为线程中就是要执行代码的，而最简单的代码封装就是函数，所以本质上还是函数调用
- 函数执行完即退出线程
线程退出
Python中没有提供线程退出的方法，线程在如下情况退出：
- 线程函数内语句执行完毕
- 线程函数内抛出异常
Python中的线程没有优先级、没有线程组的概念，也不能被销毁、停止、挂起，那也就没有恢复、中断了。
import threading
import time
def worker(): #该线程如何结束
count = 0
while True:
# for i in range(10):
time.sleep(1)
print("I'm working")
count += 1
if count >= 5:
#1 break #正常的执行完了
#2 return 100
#3 1/0
#4 raise RuntimeError()
print("Finished") #第234情况导致这一句unreachable
t = threading.Thread(target=worker,name='worker') #创建一个线程对象，此线程未运行。主线程
t.start() #启动运行一个线程
线程传参
线程传参和函数传参没什么区别，本质上就是函数传参。
threading的属性和方法
| 名称 | 含义 |
|---|---|
| current_thread() | 返回当前线程对象 |
| main_thread() | 返回主线程对象 |
| active_count() | 当前处于alive状态的线程个数 |
| enumerate() | 返回所有活着的线程的列表，不包括已经终止的线程和未开始的线程 |
| get_ident() | 返回当前线程的ID，非0整数 |
active_count、enume方法返回的值还包括主线程。
import threading
import time
def show_thread_info(i):
print(i,threading.main_thread(), threading.current_thread(), threading.active_count(), threading.enumerate())
def worker(count,name): #该线程如何结束
show_thread_info(2)
while True:
# for i in range(10):
time.sleep(1)
print("{} working".format(name))
count += 1
if count >= 3:
break #正常的执行完了
print("Finished")
show_thread_info(4)
t1 = threading.Thread(target=worker,name='worker',args=(0,'w1')) #创建一个线程对象，此线程未运行。主线程
show_thread_info(1)
time.sleep(1)
t1.start() #启动运行一个线程
print('end')
show_thread_info(3) #主线程不用等，所以这里是3先打印
Thread实例的属性和方法
| 名称 | 含义 |
|---|---|
| name | 只是一个名字，是一个标识，可以重命名。getName()、setName()获取、设置这个名词 |
| ident | 线程ID，非0整数，线程启动后才有否则为None。线程退出此ID依旧可以访问，可以重复使用 |
注：线程的name这是一个名称，可以重复；ID必须唯一，但可以在线程退出后再利用
import threading
import time
def worker(count,name): #该线程如何结束
c = threading.current_thread()
print(c.name,c.ident,'~~~~~~~~~~~')
while True:
# for i in range(10):
time.sleep(1)
print("{} working".format(name))
count += 1
if count > 3:
break #正常的执行完了
# 1/0
print("Finished")
t1 = threading.Thread(target=worker,name='worker1',args=(0,'w1'))
time.sleep(1)
t1.start() #启动一个线程
print('end')
while True: ##主线程
time.sleep(1)
if not t1.is_alive():
print('{} will restart'.format((t1.name)))
t1.start() #start方法对同一个线程对象只能用一次
#无法重启，只能重新创建其他线程对象
| 名称 | 含义 |
|---|---|
| start() | 启动线程，每一个线程必须且只能执行该方法一次 |
| run() | 运行线程函数 |
start和run的区别
import threading
import time
class MyThread(threading.Thread):
def start(self) -> None: # override 在这里除了覆盖还要调用父类的同名方法
print('start~~~~~~~~~')
super().start()
def run(self) -> None:
print('run~~~~~~~~~~~')
super().run()
def worker(count,name):
for i in range(3):
time.sleep(1)
print(threading.enumerate())
print("{} working".format(name))
print("Finished")
t1 = MyThread(target=worker,name='worker1',args=(0,'w1'))
# 创建一个线程对象，此线程未运行
time.sleep(1)
t1.start() #启动一个线程 -> run；并行
# start必须产生一个操作系统真正的新线程
# 他阻塞了吗？没有，因为他立即返回
print('**********') # 这个函数不返回就无法打印这行（但没有返回值，拿不到）
# t1.start() #再来一遍不可以，同一线程只能被start once
# t1.run() #run和start方法一样，对于同一线程只能被使用一次
# t1.run() #串行，只有一个线程（主线程），run方法不会产生线程
# 在一个线程内部，程序一定是按照顺序执行，不可以并行
# worker(0,'wwwww') # 串行
for i in range(3):
time.sleep(1)
print(threading.enumerate())
print('end')
- 使用start方法启动线程，启动了一个新线程，名字叫做worker运行。但是用run方法的并没有启动新线程，就是在主线程中调用了一个普通函数
- 因此启动线程使用start方法，且对这个线程来说start方法只能调用一次（设置_started属性实现）
多线程
即多个线程，一个进程中如果有多个线程运行，就是多线程，实现一种并发。
import threading
import time
def worker(name,interval=1):
for i in range(5):
time.sleep(interval)
print('{} working'.format(name))
t1 = threading.Thread(target=worker,args=('t1',1))
t2 = threading.Thread(target=worker,args=('t2',1))
t1.start() #最先打印end，t1、t2并行
t2.start()
# t1.run() #串行执行，最后打印end
# t2.run()
# worker('t1',1) #python的并行其实还是串行
# worker('t2',2)
print('===end===')
- 没有发开新的线程，这就是普通函数调用，所以执行完t1.run()，再执行t2.run()，这里就不是多线程（是典型串行）
- 当使用start方法启动线程后，进程内有多个活动的线程并行的工作，就是多线程。
- 一个进程中至少有一个线程，并作为程序的入口，这个线程就是主线程
一个进程至少有一个主线程，其他线程为工作线程。
daemon线程和non-daemon线程
- 注：后台线程（或守护线程）的意思
- Python中构建线程时可以设置daemon属性，这个属性必须在start方法前设置好
| 名称 | 含义 |
|---|---|
| daemon属性 | 表示线程是否是daemon线程，这个值必须在start()之前设置，否则引发RuntimeError异常 |
| isDaemon() | 是否是daemon线程*【推荐】* |
| setDaemon | 设置为daemon线程，必须在start方法之前设置*【推荐】* |
- 进行三个实验，主线程和t2线程设置为non-daemon线程，t1为daemon线程
- 实验1：t2（non-daemon）最后结束
- 实验2：t1（daemon）先结束
- 实验3：main（non-daemon）最后结束
实验1：
import threading
import time
def worker(name,timeout=1):
print(name,'enter~~~~~~~')
time.sleep(timeout)
print('{} working ++++++'.format(name))
t1 = threading.Thread(target=worker,args=('t1',5),daemon=True,name='t1')
t1.start()
t2 = threading.Thread(target=worker,args=('t2',10),name='t2')
# t2没写daemon，说明是False，因为是主线程创建，主线程是False
t2.start()
print(*threading.enumerate(),sep='\n')
print('===end===')
-----------------------------------------------
## 运行结果
t1 enter~~~~~~~
t2 enter~~~~~~~
<_MainThread(MainThread, started 12560)>
<Thread(t1, started daemon 3080)>
<Thread(t2, started 288)>
===end===
t1 working ++++++
t2 working ++++++
| 线程 | daemon | 状态 |
|---|---|---|
| main | False | 无事可做 |
| t1 | True | 5s后无事可做 |
| t2 | False | 10s后无事可做，进程结束 |
实验2：
import threading
import time
def worker(name,timeout=1):
print(name,'enter~~~~~~~')
time.sleep(timeout)
print('{} working ++++++'.format(name))
t1 = threading.Thread(target=worker,args=('t1',10),daemon=True,name='t1')
t1.start()
t2 = threading.Thread(target=worker,args=('t2',5),name='t2')
# t2没写daemon，说明是False，因为是主线程创建，主线程是False
t2.start()
print(*threading.enumerate(),sep='\n')
print('===end===')
-----------------------------------------------
## 运行结果
t1 enter~~~~~~~
t2 enter~~~~~~~
<_MainThread(MainThread, started 16040)>
<Thread(t1, started daemon 7044)>
<Thread(t2, started 9084)>
===end===
t2 working ++++++
| 线程 | daemon | 状态 |
|---|---|---|
| main | False | 无事可做 |
| t1 | True | 没有到10s进程就已经结束 |
| t2 | False | 5s后无事可做，进程结束 |
实验3：
import threading
import time
def worker(name,timeout=1):
print(name,'enter~~~~~~~')
time.sleep(timeout)
print('{} working ++++++'.format(name))
t1 = threading.Thread(target=worker,args=('t1',8),daemon=True,name='t1')
t1.start()
t2 = threading.Thread(target=worker,args=('t2',5),name='t2')
# t2没写daemon，说明是False，因为是主线程创建，主线程是False
t2.start()
print(*threading.enumerate(),sep='\n')
time.sleep(10)
print('===end===')
-----------------------------------------------
## 运行结果
t1 enter~~~~~~~
t2 enter~~~~~~~
<_MainThread(MainThread, started 22232)>
<Thread(t1, started daemon 12728)>
<Thread(t2, started 11200)>
t2 working ++++++
t1 working ++++++
===end===
| 线程 | daemon | 状态 |
|---|---|---|
| main | False | 10s后无事可做 进程结束 |
| t1 | True | 8s后无事可做 |
| t2 | False | 5s后无事可做 |
- 这说明，如果还有non-daemon线程在运行，进程不结束，进程也不会杀掉其他所有daemon线程，直到所有non-daemon线程全部结束（包括主线程），不管有没有daemon线程，程序退出
总结
- 线程有一个daemon属性，可以手动设置为True或False，也可以不设置，则取默认值None
- 如果不设置daemon，就取当前线程的daemon来设置
- 主线程是non-daemon线程，即daemon = False
- 从主线程创建的所有线程的不设置daemon属性，则默认都是daemon = False，也就是non-daemon线程
- Python程序在没有活着的non-daemon线程运行时，程序退出，也就是除主线程之外剩下的只能都是daemon线程，主线程才能退出，否则主线程就只能等待
join方法
import threading
import time
def worker(name,timeout=1):
print(name,'enter~~~~~~~')
for i in range(timeout):
time.sleep(1)
if i > 3:
1/0
print('+++++++')
print('{} working ++++++'.format(name))
t = threading.Thread(target=worker,args=('t1',8),daemon=True)
t.start()
# t.join()
# t.join(2) #主线程等待两秒，卡了（阻塞）两秒
# print('-'*30)
# t.join(2)
# print('-'*30)
t.join() #永久阻塞主线程，到t线程结束运行
# t.join() 加入t，调用者（主线程）等他
print('='*30)
- 使用join方法后，当前线程阻塞，daemon线程执行完了主线程才退出。
- join方法是线程的标准方法之一
- 一个线程中调用另一线程的join方法，调用者将被阻塞，直到被调用线程终止，或阻塞超时
- 一个线程可以被join多次
- timeout参数执行调用者等待多久，没有设置超时，就一直等到被调用线程结束
- 调用谁的join方法，就是join谁，就要等谁
- join保证当前一定要执行完（如果是无限循环则会使该线程永久阻塞）
daemon线程应用场景
主要应用场景：
- 后台任务。（如发送心跳包、监控，这种场景最多）
- 主线程工作才有用的线程，如主线程中维护这公共的资源，主线程已经清理了，准备退出，而工作线程使用这些资源工作也没有意义，一起退出最合适
- 随时可以被终止的线程
- 如果主线程退出，向所有其他工作线程一起退出，就是用daemon = True来创建工作线程
- daemon线程，简化了程序员手动关闭线程的工作
- daemon方法和join方法时常配合使用：
- 如果在non-daemon线程A中，对另一个daemon线程B使用了join方法，这个线程B设置成daemon就没意义了，因为non-daemon线程A总要等待线程B；
- 如果在一个daemon线程C中，对另一个daemon线程D使用了join方法，只能说明C要等待D，主线程退出，不管CD是否结束也不管谁在等谁，都要被杀掉。
import threading
import time
def worker2(name):
while True:
time.sleep(1)
print('{} working'.format(name),threading.current_thread().isDaemon())
def worker1(name):
current = threading.current_thread()
print("{}'s daemon = {}".format(name,current.isDaemon()))
t2 = threading.Thread(target=worker2,args=('t2',),name='t2')
# t2 = threading.Thread(target=worker2,args=('t2',),daemon=False,name='t2')
# daemon为False，t1t2都是non-daemon线程，t2会无限进行下去不会被杀死
t2.start()
t1 = threading.Thread(target=worker1,args=('t1',),daemon=True,name='t1')
#daemon为True，t1t2都是daemon线程，t1在4s内创建出t2（父子关系），但并不代表t1被杀死后t2无法存活，所以t2依旧打印了几次之后被杀死，进程结束
t1.start()
time.sleep(4)
print('Main Thread Exits')
print(threading.active_count()) #还有两个线程存活
print(threading.enumerate()) #存活的是主线程和t2
-----------------------------------------------
## 运行结果
t1's daemon = True
t2 working True
t2 working True
t2 working True
Main Thread Exits
2
[<_MainThread(MainThread, started 14532)>, <Thread(t2, started daemon 17616)>]
- 可以使用join方法让线程结束不了：
import threading
import time
def worker2(name):
while True:
time.sleep(1)
print('{} working'.format(name),threading.current_thread().isDaemon())
def worker1(name):
current = threading.current_thread()
print("{}'s daemon = {}".format(name,current.isDaemon()))
t2 = threading.Thread(target=worker2,args=('t2',),name='t2')
# daemon为False，t1t2都是non-daemon线程，t2会无限进行下去不会被杀死
t2.start()
t2.join()
t1 = threading.Thread(target=worker1,args=('t1',),daemon=True,name='t1')
#daemon为True，t1t2都是daemon线程，t1在4s内创建出t2（父子关系），但并不代表t1被杀死后t2无法存活，所以t2依旧打印了几次之后被杀死，进程结束
t1.start()
t1.join() #阻塞在这句,下面都运行不到
time.sleep(4)
print('Main Thread Exits')
print(threading.active_count()) #还有两个线程存活
print(threading.enumerate()) #存活的是主线程和t2
threading.local类
import threading
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT,level=logging.INFO)
# z = [] #全局变量，不安全，但不见得一定会暴露问题
def worker():
y = [] #安全的不得了！！局部变量
x = 0 #x非常安全，局部的
for i in range(1000):
time.sleep(0.0001)
x += 1
logging.info("x = {}".format(x))
for i in range(10): #每次函数调用都是独立的，多个线程互不干扰
threading.Thread(target=worker,name='w{}'.format(i,)).start()
-----------------------------------------------
## 运行结果
2020-07-23 11:00:14,126 w3 10072 x = 1000
2020-07-23 11:00:14,128 w7 15108 x = 1000
2020-07-23 11:00:14,133 w0 12468 x = 1000
2020-07-23 11:00:14,134 w2 19648 x = 1000
2020-07-23 11:00:14,136 w6 22084 x = 1000
2020-07-23 11:00:14,137 w4 20176 x = 1000
2020-07-23 11:00:14,140 w1 22900 x = 1000
2020-07-23 11:00:14,141 w5 15480 x = 1000
2020-07-23 11:00:14,142 w9 21888 x = 1000
2020-07-23 11:00:14,143 w8 20920 x = 1000
- 每个线程完成不同的计算任务
- x是局部变量，每次函数调用都是独立的，每个线程独立不干扰
改造成全局变量：
import threading
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT,level=logging.INFO)
class A:
def __init__(self):
self.x = 0
# x = 0
g_data = A()
def worker():
# y = [] #安全的不得了！！局部变量
# x = 0 #x非常安全，局部的
# global x
# x = 0 # 最后每个线程输出的值是多少
# g_data.x = 0
for i in range(1000):
time.sleep(0.0001)
g_data.x += 1
logging.info("x = {}".format(g_data.x))
for i in range(10): #每次函数调用都是独立的，多个线程互不干扰
threading.Thread(target=worker,name='w{}'.format(i,)).start()
print('-'*30)
-----------------------------------------------
## 运行结果
2020-07-23 11:01:00,912 w3 22312 x = 9955
2020-07-23 11:01:00,916 w7 23356 x = 9974
2020-07-23 11:01:00,919 w2 3308 x = 9988
2020-07-23 11:01:00,919 w4 22384 x = 9989
2020-07-23 11:01:00,920 w0 17708 x = 9991
2020-07-23 11:01:00,920 w1 1712 x = 9994
2020-07-23 11:01:00,921 w5 22236 x = 9996
2020-07-23 11:01:00,922 w9 23168 x = 9997
2020-07-23 11:01:00,922 w6 21212 x = 9999
2020-07-23 11:01:00,924 w8 20540 x = 10000
- 虽然使用了全局对象，但线程之间互相干扰，此时线程不安全
- 线程安全：多线程执行一段代码，不会产生不确定的结果，即为线程安全
- 线程不安全：使用了多线程导致结果不确定（上例中原因在A类上）
使用threading.local：
import threading
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
X = 200
g = threading.local() #thread-local
g.x = 100 # thread-local对象，属性创建在什么线程，什么线程可用
print(g.x, X)
def xyz():
print(X) # 全局变量
# print(g.x) # g存在，但没有x属性
g.y = 300
logging.info(g.y)
xyz()
print('-'*30)
time.sleep(2)
t = threading.Thread(target=xyz)
t.start()
t.join()
print('='*30)
time.sleep(2)
print(g.y) #300
-----------------------------------------------
## 运行结果
100 200
200
------------------------------
2020-07-23 11:41:34,906 MainThread 15796 300
2020-07-23 11:41:36,907 Thread-1 1860 300
200
==============================
300
- threading.local类构建了一个大字典，存放所有线程相关的字典
- 每一线程实例的id为key，元祖为value
- value中两部份为线程对象引用，每个线程自己的字典
- 本质：
- 运行时，threading.local实例处在不同线程中，就从大字典中找到当前线程相关键值对中的字典，覆盖threading.local实例的__dict__
- 这样就可以在不同的线程中，安全的使用线程独有的数据，做到了线程间数据隔离，如同本地变量一样安全。
线程同步
线程同步、线程间协同，通过某种技术让一个线程访问某些数据时，其他线程不能访问这些数据，直到该线程完成对数据的操作
Event
Event事件，是线程间通信机制中最简单的实现，使用一个内部的标记flag，通过flag的True或False的变化来进行操作
| 名称 | 含义 |
|---|---|
| set() | 标记设置为True |
| clear() | 标记设置为False |
| is_set() | 标记是否为True |
| wait(timeout=None) | 设置等待标记为True的时长，None为无限等待，等到返回True，未等到超时则返回False |
例：生产杯子
import threading
import time
from threading import Event
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
# 线程，Event状态变化
# 有一个老板，一个工人，老板让工人生产10个cups，老板一直盯着工人工作，知道工人完成，老板夸了一句“good job”
cups = []
# flag = False
event = threading.Event() # 0
def boss(e:threading.Event):
logging.info('I am watching u')
e.wait() #一直等
logging.info('Good job')
def worker(e:threading.Event,count=10):
logging.info('I am working for u')
while len(cups)<count:
time.sleep(0.5)
cups.append(1)
logging.info('made one')
# flag = True # 有问题，怎么改？
e.set() # 0 -> 1
logging.info('Finished my job.')
b = threading.Thread(target=boss,name='boss',args=(event,))
b.start()
w = threading.Thread(target=worker,name='worker',args=(event,))
w.start()
-----------------------------------------------
## 运行结果
2020-07-23 16:20:35,196 boss 21228 I am watching u
2020-07-23 16:20:35,197 worker 14776 I am working for u
2020-07-23 16:20:35,698 worker 14776 made one
2020-07-23 16:20:36,199 worker 14776 made one
2020-07-23 16:20:36,700 worker 14776 made one
2020-07-23 16:20:37,201 worker 14776 made one
2020-07-23 16:20:37,702 worker 14776 made one
2020-07-23 16:20:38,203 worker 14776 made one
2020-07-23 16:20:38,704 worker 14776 made one
2020-07-23 16:20:39,205 worker 14776 made one
2020-07-23 16:20:39,706 worker 14776 made one
2020-07-23 16:20:40,206 worker 14776 made one
2020-07-23 16:20:40,206 worker 14776 Finished my job.
2020-07-23 16:20:40,206 boss 21228 Good job
总结
- 需要使用同一个Event对象的标记flag
- 谁wait就是等到flag变为True，或等到超时返回False
- 不限制等待者个数，通知所有等待者
wait的使用
import threading
import time
from threading import Event
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
cups = []
event = threading.Event()
def worker(e:threading.Event,count=10):
logging.info('I am working for u')
while not event.wait(0.5): # 或while not event.is_set()+time.sleep(0.5)# 二者选其一，效果一样
# time.sleep(0.5)
# event.wait(2)
cups.append(1)
logging.info('made one')
if len(cups) >= count:
event.set()
# break
logging.info('Finished my job.')
threading.Thread(target=worker,name='worker',args=(event,)).start()
-----------------------------------------------
## 运行结果
2020-07-25 10:04:52,818 worker 9352 I am working for u
2020-07-25 10:04:53,318 worker 9352 made one
2020-07-25 10:04:53,819 worker 9352 made one
2020-07-25 10:04:54,319 worker 9352 made one
2020-07-25 10:04:54,819 worker 9352 made one
2020-07-25 10:04:55,320 worker 9352 made one
2020-07-25 10:04:55,821 worker 9352 made one
2020-07-25 10:04:56,321 worker 9352 made one
2020-07-25 10:04:56,822 worker 9352 made one
2020-07-25 10:04:57,323 worker 9352 made one
2020-07-25 10:04:57,823 worker 9352 made one
2020-07-25 10:04:57,823 worker 9352 Finished my job.
定时器Timer / 延迟执行
threading.Timer继承自Thread，这个类用来定义延迟多久后执行一个函数
class threading.Timer(interval, function, args=None, kwargs=None)
start方法执行之后，Timer对象处于等待状态，等待了interval秒之后，开始执行function函数的。
import threading
from threading import Timer # 定时器
import time
def worker(name): # 线程Thread，target是run执行的
print('{} is working'.format(name))
time.sleep(10)
print("{} said: 'I have finished my work'".format(name))
t = Timer(3, worker,('tom',)) # Thread子类 # cancel
# t.cancel() # 提前取消
t.start() # 启动了，返回了（一定会启动一个线程）
time.sleep(2)
t.cancel() # 线程启动但没有打印
print(threading.enumerate())
time.sleep(5)
# t.cancel() # t线程刚运行起来就被取消了
print("===Main Exits===")
- 上例中，工作线程早就启动了，但在工作线程中延迟了3s才执行的worker函数
- Timer是现成Thread的子类，Timer实力内部提供了一个finished属性，该属性是Event对象。cancel方法本质上是在worker函数执行前对finished属性set方法操作，从而跳过worker函数执行，达到取消效果
总结
- Timer是现成Thread的子类，就是线程类，具有线程的能力和特征
- 他的实例能够延时执行目标函数的线程，在真正执行目标函数之前，都可以cancel他
- cancel方法本质时使用Event类实现，这并不是说线程提供了取消的方法
Lock
锁，一旦线程获得锁，其他试图获取锁的线程将被阻塞
锁：凡是存在共享资源争抢的地方都可以用锁，从而保证只有一个使用者可以完全使用这个资源。
| 名称 | 含义 |
|---|---|
| acquire (blocking=True, timeout=-1) | 默认阻塞，阻塞可以设置超过时间。非阻塞时，timeout禁止设置。成功获取锁，返回True，否则返回False |
| release() | 设防锁，可以从任何线程调用释放。已上锁的锁，会被重置为unlock未上锁的锁上调用，抛出RuntimeError异常。 |
锁的基本使用
import threading
from threading import Timer # 定时器
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
lock = threading.Lock()
x = lock.acquire()# True拿到了
print(x)
def worker(l:threading.Lock):
name = threading.current_thread().name
print(name, 'wants to get locker')
logging.info(l.acquire())
print(name,'finished')
for i in range(5):
threading.Thread(target=worker, name='w{}'.format(i), args=(lock,)).start()
time.sleep(2)
while True:
time.sleep(1)
cmd = input(">>>")
if cmd == 'r':
lock.release()
elif cmd =='quit':
break
else:
print(threading.enumerate())
-----------------------------------------------
## 运行结果
True
w0 wants to get locker
w1 wants to get locker
w2 wants to get locker
w3 wants to get locker
w4 wants to get locker
>>>r
w0 finished
>>>r
w1 finished
>>>r
w2 finished
>>>r
w3 finished
>>>r
w4 finished
>>>r
>>>quit
- 不管在哪个线程中，只要对一个已经上锁的锁阻塞请求，该线程就会阻塞
例：有十个工人，生成1000个cups，直到所有工人完成任务，结束工作（不管老板）
import threading
from threading import Timer
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
lock = threading.Lock()
cups = []
def worker(l:threading.Lock,count=1000):
logging.info('{} is working'.format(threading.current_thread().name))
while len(cups) < count:
time.sleep(0.001)
cups.append(1)
# logging.info('made one')
logging.info("{} finished {} cups".format(threading.current_thread().name,len(cups)))
for i in range(5):
threading.Thread(target=worker, name='w{}'.format(i),args=(lock,)).start()
-----------------------------------------------
## 运行结果
2020-07-25 10:14:55,556 w0 11416 w0 is working
2020-07-25 10:14:55,557 w1 18992 w1 is working
2020-07-25 10:14:55,557 w2 1576 w2 is working
2020-07-25 10:14:55,557 w3 17856 w3 is working
2020-07-25 10:14:55,558 w4 16456 w4 is working
2020-07-25 10:14:55,945 w1 18992 w1 finished 1000 cups
2020-07-25 10:14:55,945 w0 11416 w0 finished 1001 cups
2020-07-25 10:14:55,946 w3 17856 w3 finished 1002 cups
2020-07-25 10:14:55,946 w2 1576 w2 finished 1003 cups
2020-07-25 10:14:55,947 w4 16456 w4 finished 1004 cups
为何会超界？？（如果去掉time.sleep不会超界）
修改：加锁解锁之后
import threading
from threading import Timer
import time
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
# 有十个工人，生成1000个cups，直到所有工人完成任务，结束工作
lock = threading.Lock()
cups = []
def worker(l:threading.Lock,count=1000):
logging.info('{} is working'.format(threading.current_thread().name))
flag = False
while True:
l.acquire() #加锁
if len(cups) >= count:
flag = True
# l.release() #第一次release
time.sleep(0.001)
if not flag:
cups.append(1)
l.release() #第二次release
if flag:
break
# l.release() #第三次release
logging.info("{} finished {} cups".format(threading.current_thread().name,len(cups)))
for i in range(10):
threading.Thread(target=worker, name='w{}'.format(i),args=(lock,)).start()
-----------------------------------------------
## 运行结果
2020-07-25 10:37:52,860 w0 3396 w0 is working
2020-07-25 10:37:52,860 w1 3904 w1 is working
2020-07-25 10:37:52,861 w2 9520 w2 is working
2020-07-25 10:37:52,861 w3 8220 w3 is working
2020-07-25 10:37:52,862 w4 13728 w4 is working
2020-07-25 10:37:52,862 w5 23884 w5 is working
2020-07-25 10:37:52,862 w6 18328 w6 is working
2020-07-25 10:37:52,863 w7 9256 w7 is working
2020-07-25 10:37:52,863 w8 8440 w8 is working
2020-07-25 10:37:52,863 w9 14472 w9 is working
2020-07-25 10:37:54,727 w3 8220 w3 finished 1000 cups
2020-07-25 10:37:54,729 w9 14472 w9 finished 1000 cups
2020-07-25 10:37:54,731 w6 18328 w6 finished 1000 cups
2020-07-25 10:37:54,733 w4 13728 w4 finished 1000 cups
2020-07-25 10:37:54,735 w1 3904 w1 finished 1000 cups
2020-07-25 10:37:54,737 w5 23884 w5 finished 1000 cups
2020-07-25 10:37:54,739 w0 3396 w0 finished 1000 cups
2020-07-25 10:37:54,741 w7 9256 w7 finished 1000 cups
2020-07-25 10:37:54,743 w8 8440 w8 finished 1000 cups
2020-07-25 10:37:54,745 w2 9520 w2 finished 1000 cups
修改后分析：
- 加锁只有一处。
- 十个人生产十个杯子，箱子里别的地方都被占住，其中一个工人A抢过箱子盖住，发现里面还有一个杯子需要生产，此时工人A需要生产一个杯子。在他生产完把箱子打开之前，其他工人不能看到箱子里的情况（即释放锁之前，其他线程阻塞），因此release 1是错误的，不可以，会导致超界。
- 在某时刻正好箱子被填满，在此之前除去生产最后一个杯子的工人A谁也拿不到箱子，结束最后一个杯子生产，工人A打开箱子，其他工人再抢到箱子时发现箱子已经满了，就不需要再生产了（即锁在此释放后其他线程再抢到锁，发现条件已被满足，只好break退出）。因此release 2是正确的，能保证正好生产1000个杯子。
- if flag: break 是为了保证release 2被执行，否则就出现了死锁，得到锁的完成任务直接退出，没有释放，其他线程也永远拿不到，永远在l.acquire那句阻塞。因此release 3是错误的。
加锁、解锁
一般来说，加锁就需要解锁，但加锁后解锁前还有有一些代码需要执行，就有可能抛异常，一旦出现异常，锁无法释放，当前线程可能会因此终止从而产生死锁（非常危险！！！）
加锁、解锁常用语句：
- 使用try…finally语句保证锁释放
- with上下文管理，锁对象支持上下文管理
例：Balancer
import threading
from threading import Lock
class Balancer:
def __init__(self):
self._value = 0
self.__lock = threading.Lock()
def inc(self):
with self.__lock:
self._value += 1
def dec(self):
with self.__lock:
self._value -= 1
@property
def value(self):
with self.__lock:
return self._value #需要加锁吗？
def run(c:Balancer,count):
for i in range(count):
for j in range(-50,50):
if j < 0:
c.dec()
else:
c.inc()
c = Balancer()
threads = 10 #10 0;100 0;1000 0
count = 1000 #10 0;100 0;1000 不确定
for i in range(threads):
threading.Thread(
target=run,
args=(c,count),
name="balancer-{}".format(i)
).start()
print(c.value) # ?
# 加锁、解锁
- 如果读取属性的时候不加锁，那么就可以读取到脏数据
- 对同一个数据，多个线程争着写入时一般都需要加锁，保证只有一个线程能够写入，直到数据成功写入后释放锁。
锁的应用场景
- 锁适用于访问喝修改同一个共享资源时，即读写同一个资源时
- 如果全部都是读取同一个共享资源时是不需要锁的，因为这是可以认为共享资源是不可变的，每次读取他都是一样的值，所以不用加锁
- 使用锁的注意事项：
- 少用锁，只在必要时用锁，使用锁多线程访问被锁的资源时，就成了串行；要么排队要么争抢
- 加锁时间越短越好，不需要就立即释放锁（因为会造成阻塞）
- 一定要避免死锁！！！！
- 不使用锁有了效率，但结果是错的；使用了锁效率低下，但结果是对的；这种情况下我们还是要选择正确的结果
可重入锁（递归锁）RLock
- 可重入锁是线程相关的锁
- 线程A获得可重复锁，并可以多次成功获取，不会阻塞。最后要在线程A中做和acquire次数相同的release
import time
import threading
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
print(threading.get_ident(),'+++++')
l = threading.RLock()
logging.info("1 {} {}".format(l.acquire(),l))
logging.info('-'*30)
logging.info("2 {} {}".format(l.acquire(),l))
def worker(l):
logging.info('in worker~~~~~~~~~~~~')
print(threading.get_ident())
logging.info(l)
# l.release() #不是他的锁，不可以
logging.info(l.acquire())
logging.info(l)
logging.info('get one locker')
t = threading.Thread(target=worker,name='worker',args=(l,))
t.start()
logging.info('='*30)
可重入锁
- 与线程相关，可在一个线程中获取锁，并可继续在同一线程中不阻塞多次获取锁
- 当锁未释放完，其他线程获取锁就会阻塞，知道当前持有锁的线程释放锁
- 锁都应该使用完后释放。可重入锁也是所，应该acquire多少次就release多少次
Condition
构造方法Condition(lock=None)，可以传入一个Lock或RLock对象，默认Lock
| 名称 | 含义 |
|---|---|
| acquire(*args) | 获取锁 |
| wait(self, timeout=None) | 等待或超时 |
| notify(n=1) | 唤醒至多指定数目个数的等待的线程，没有等待的线程就没有任何操作 |
| notify_all() | 唤醒所有等待的线程 |
Condition基本使用：
例：生产杯子
import time
import threading
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
#两个老板盯着一个工人生产1000个杯子
cond = threading.Condition()
def boss():
logging.info('I am watching u')
with cond:
logging.info('我等')
cond.wait()
logging.info('Good Job')
def worker(count=1000):
logging.info('Starting....')
cups = []
while len(cups) < 1000:
time.sleep(0.0001)
cups.append(1)
with cond:
cond.notify_all()
# cond.notify(1) # 只通知一位，阻塞
logging.info('finished. cups={}'.format(len(cups)))
b1 = threading.Thread(target=boss,name='b1')
b2 = threading.Thread(target=boss,name='b2')
b1.start()
b2.start()
w = threading.Thread(target=worker,name='worker')
w.start()
- Condition用于生产者、消费者模型，为了解决生产者消费者的速度匹配问题
例：生产者消费者模型
import time
import threading
from threading import Event,Condition
import logging
import random
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
#生产者消费者模型
class Dispatcher:
def __init__(self):
self.data = None
self.event = threading.Event()
self.cond = threading.Condition()
def produce(self):
logging.info('Starting....')
while True:
time.sleep(1)
self.data = random.randint(1,50)
logging.info(self.data)
with self.cond:
self.cond.notify_all()
def consume(self):
logging.info('consume~~~~~~')
# while not self.event.wait(0.5) # 最大的问题在于消费者主动轮询获取数据（消耗大量不该消耗的时间）
while True:
with self.cond:
self.cond.wait()
data = self.data
# self.data = None
logging.info(data)
d = Dispatcher()
p = threading.Thread(target=d.produce,name='producer')
for i in range(5):
c = threading.Thread(target=d.consume,name='consumer{}'.format(i))
c.start()
p.start()
- 上例采取了消费者主动消费，消费者浪费了大量时间轮询查看有没有数据
- 为了节约时间成本资源消耗，使用Condition对象
- 使用notify_all实现了消息的一对多，这其实就是广播模式
- 注：上例中程序本身不是线程安全的，但可以帮助理解Condition和生产者消费者模型
Condition总结
- Condition用于生产者消费者模型中，解决生产者消费者速度匹配的问题，采用通知机制很有效率
- 使用方式：
使用Condition，必须先acquire，用完之后release，因为内部其实使用了锁，默认使用RLock锁，最好是用with上下文 - 消费者wait，等待通知；生产者生产完毕给消费者发通知，可以使用notify或notify_all方式
semaphore信号量
- 和Lock很像，信号量对象内部维护一个倒计数器，每次acquire都会减1，当acquire方法发现计数为0是久阻塞请求的线程，直到其他线程对信号量release后，计数大于0，恢复阻塞的线程
| 名称 | 含义 |
|---|---|
| Semaphore(value=1) | 构造方法。value小于0，抛ValueError异常 |
| acquire(blocking=True,timeout=None) | 获取信号量，计数器-1，获取成功返回True |
| release() | 释放信号量，计数器+1 |
- 计数器永远不会低于0，因为acquire的时候发现是0都会被阻塞
import time
import threading
import logging
from threading import Semaphore, Thread
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
# 信号量
s = threading.Semaphore(3)
logging.info(s.acquire())
logging.info(s._value)
logging.info(s.acquire())
logging.info(s._value)
logging.info(s.acquire())
logging.info(s._value)
logging.info('------------')
# logging.info(s.acquire()) #阻塞了，可以用timeout
def worker():
logging.info(s)
logging.info(s.__dict__)
logging.info(s.acquire())
# s.release()
# logging.info('release s one time')
logging.info(s.__dict__)
threading.Timer(5,worker).start()
time.sleep(3)
s.release()
logging.info(s.__dict__)
logging.info('gor it')
BoundedSemaphore类
- 有界的信号量，不允许使用release超出初始值的范围，否则抛出ValueError的异常
例：连接池
- 因为资源有限，且开启一个连接成本高所以使用连接池
- 一个简单的连接池应该有容量（总数），有一个工厂方法可以获取连接，能够把不用的连接返回，供其他使用者调用
import time
import threading
import logging
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
# 信号量
# pool 游泳池，池中资源获得很不容易，但我们用的很频繁，而且还要复用。连接池 创建连接维护链接非常耗资源。线程池、进程池
class Conn:
def __init__(self,name):
self.name = name
class Pool:
def __init__(self,count=5):
self._count = count
# 一上来我们就创建五个线程
self.__pool = [self._connent('cn-{}'.format(i)) for i in range(count)]
# self._lock = threading.Lock() 可以用加锁
self.sema = threading.BoundedSemaphore(count)
def _connent(self,name):
return Conn(name)
def get_conn(self): #None
# with self._lock:
# if len(self.__pool) > 0: #说明还有资源
self.sema.acquire()
return self.__pool.pop()
def return_conn(self,conn:Conn):
self.__pool.append(conn)
self.sema.release()
pool = Pool(3)
pool.return_conn(Conn('test'))
print(pool.sema.__dict__)
假设池中正好有一个链接，有可能多个线程判断了池的长度大于0，当一个线程拿走了连接对象，其他线程再来pop就会抛异常，解决方法如下：
- 加锁，在读写的地方加锁（get_conn）
- 使用信号量Semaphore
上例中，如果池中有资源，请求者获取资源时信号量-1，拿走资源；当请求超过资源数，请求者只能等待。当使用者用完归还资源后信号量+1，等待线程就可以被唤醒拿走资源
问题：
- 边界问题分析：
- return_conn方法可以单独执行，有可能多归还连接，（多release），所以要用有界信号量BoundedSemaphore类
- 假设上例中最后两行代码位置调换，可能会产生边界时多个线程都争抢写入，最终导致超界抛异常的问题因此信号量可以保证一定不能多归还
- 正常使用分析：
- 正常使用信号量都会先获取，用完后归还
- 创建很多线程，都去获取信号量，没有获得信号量的线程都阻塞。能归还的县城都是前面获取到信号量的线程，其他没有获得线程都阻塞。非阻塞线程append后才release，这时候等待的线程都被唤醒，才能继续append，也就是没有获取信号量的线程就不能继续append，此事时线程安全。
信号量和锁
- 信号量，可以多个线程访问共享资源，但这个共享资源数量有限
- 锁，可以看作特殊的信号量，即信号量计数器初始值为1，只允许同一个时间一个线程独占资源
Queue得线程安全
- 标准库Queue模块，提供FIFO的Queue、LIFO的队列、优先队列
- Queue类是线程安全的，适用于多线程间安全的交换数据，内部使用了Lock和Condition
- 实现容器大小这个说法并不准确，如果不加锁，是不可能获取准确大小的，因为判断大小和put、get方法是分开执行的，读取时可能就被其他线程更改数据了
- Quue类的size虽然加了锁，但仍不能保证立即get、put成功，因为读取大小和get、put方法分开。
GIL全局解释器锁
-
GIL保证CPython进程中，只有一个线程执行字节码。甚至在多核CPU情况下，也只允许同时只能有一个CPU和欣赏运行该进程的一个线程
-
CPython中：
- IO密集型，某个线程阻塞，GIL释放，就会调度其他就绪线程
- CPU密集型，当前线程可能会连续获得GIL，导致其他线程几乎无法使用CPU
- 在CPython中由于有GIL存在，IO密集型，使用多线程较为合算；CPU密集型，使用多进程，要绕开GIL
-
Python中绝大多数内置数据结构的读、写操作都是原子操作
-
由于GIL的存在，Python的内置数据类型在多线程编程时就变成了安全的，但其实他们本身不是线程安全类型。
-
保留GIL使Python对初学者更友好，不需要高深的系统知识也能安全简单的使用Python；移除GIL也会降低CPython单线程的执行效率
程序1：
import threading
import logging
import datetime
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
def calc():
s = 0
for i in range(100000000): #1亿次
s += 1
logging.info(s)
start = datetime.datetime.now()
calc()
calc()
calc()
calc() #纯串行
delta = (datetime.datetime.now() - start).total_seconds()
print('串行 耗时={}s'.format(delta))
-----------------------------------------------
## 运行结果
2020-07-27 16:30:46,191 MainThread 27112 100000000
2020-07-27 16:30:49,941 MainThread 27112 100000000
2020-07-27 16:30:53,675 MainThread 27112 100000000
2020-07-27 16:30:57,558 MainThread 27112 100000000
串行 耗时=15.121078s
程序2：
import threading
import logging
import datetime
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO)
def calc():
s = 0
for i in range(100000000): #1亿
s += 1
logging.info(s)
start = datetime.datetime.now()
c1 = threading.Thread(target=calc,name='c1')
c2 = threading.Thread(target=calc,name='c2')
c3 = threading.Thread(target=calc,name='c3')
c4 = threading.Thread(target=calc,name='c4') #并行（其实是假并行，因为GIL）
c1.start()
c2.start()
c3.start()
c4.start()
c1.join()
c2.join()
c3.join()
c4.join()
delta = (datetime.datetime.now() - start).total_seconds()
print('并行 耗时={}s'.format(delta))
-----------------------------------------------
## 运行结果
2020-07-27 16:31:46,086 c1 19448 100000000
2020-07-27 16:31:49,089 c4 20088 100000000
2020-07-27 16:31:51,305 c3 19144 100000000
2020-07-27 16:31:51,640 c2 22256 100000000
并行 耗时=15.740096s
- 注：不要再代码中出现print等访问IO的语句，访问IO会造成线程阻塞，释放GIL锁，其他线程被调度
- 程序1是单线程程序，所有calc()依次执行，根本不是并发。在主线程内，函数串行执行。
- 程序2使多线程程序，calc()执行在不同的线程中，但由于GIL的存在，线程的执行变成了假并发。但这些线程可以被调度到不同的CPU上执行，只不过GIL让同一时间该进程只有一个线程被执行
- 因此CPython中多线程并没有优势，和一个线程执行时间相当，因为GIL的存在，有i是计算密集型程序，和单线程串行效果相当。这样实际上没有用到CPU多核心的优势。
1108
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
