29期第十九周笔记

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中没有提供线程退出的方法,线程在如下情况退出:

  1. 线程函数内语句执行完毕
  2. 线程函数内抛出异常

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线程应用场景

主要应用场景:

  1. 后台任务。(如发送心跳包、监控,这种场景最多)
  2. 主线程工作才有用的线程,如主线程中维护这公共的资源,主线程已经清理了,准备退出,而工作线程使用这些资源工作也没有意义,一起退出最合适
  3. 随时可以被终止的线程
  • 如果主线程退出,向所有其他工作线程一起退出,就是用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是错误的。

加锁、解锁

一般来说,加锁就需要解锁,但加锁后解锁前还有有一些代码需要执行,就有可能抛异常,一旦出现异常,锁无法释放,当前线程可能会因此终止从而产生死锁(非常危险!!!)

加锁、解锁常用语句:

  1. 使用try…finally语句保证锁释放
  2. 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就会抛异常,解决方法如下:

  1. 加锁,在读写的地方加锁(get_conn)
  2. 使用信号量Semaphore

上例中,如果池中有资源,请求者获取资源时信号量-1,拿走资源;当请求超过资源数,请求者只能等待。当使用者用完归还资源后信号量+1,等待线程就可以被唤醒拿走资源

问题:
  1. 边界问题分析:
  • return_conn方法可以单独执行,有可能多归还连接,(多release),所以要用有界信号量BoundedSemaphore类
  • 假设上例中最后两行代码位置调换,可能会产生边界时多个线程都争抢写入,最终导致超界抛异常的问题因此信号量可以保证一定不能多归还
  1. 正常使用分析:
  • 正常使用信号量都会先获取,用完后归还
  • 创建很多线程,都去获取信号量,没有获得信号量的线程都阻塞。能归还的县城都是前面获取到信号量的线程,其他没有获得线程都阻塞。非阻塞线程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多核心的优势。
©️2020 CSDN 皮肤主题: 深蓝海洋 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值