1.线程基础知识
1.1 进程与线程的区别
进程:
- 创建进程 时间开销大
- 销毁进程 时间开销大
- 进程之间切换 时间开销大
线程:
线程是进程中的一部分(不能脱离进程存在),每一个进程中至少有一个线程。
开销:
线程的创建,也需要一些开销(一个存储局部变量(临时变量)的结构,记录状态)
线程的创建、销毁、切换开销远远小于进程——开销小
进程是计算机中最小的资源分配单位(进程是负责圈资源)
线程是计算机中能被CPU调度的最小单位(线程是负责执行具体代码的)
线程是由 操作系统 调度,由操作系统负责切换的。
python中的线程比较特殊,所以进程也有可能被用到
注意:一般不建议开起多个进程,但一个进程可以开起多个线程,来减小开销。
特点:
- 进程 :数据隔离 开销大 同时执行几段代码
- 线程 :数据共享 开销小 同时执行几段代码
1.2 线程的理论
cpython解释器 — 不能实现多线程利用多核
python中垃圾回收机制 gc :引用计数 + 分代回收
专门有一条线程来完成垃圾回收,对每一个在程序中的变量统计引用计数
锁 :GIL 全局解释器锁
- 保证了整个python程序中,只能有一个线程被CPU执行
只能有一个线程被CPU执行原因:
- cpython解释器中特殊的垃圾回收机制
GIL锁导致了线程不能并行,但可以并发,所以使用多线程并不影响高io型的操作,只会对高计算型的程序有效率上的影响。
遇到高计算可以采用的方式:
- 多进程 + 多线程
- 分布式
cpython / pypy(pypython) 有垃圾回收机制,只能有一个线程被CPU执行,所以有全局解释器锁
jpython / iron python 没有垃圾回收机制,可以有多个线程被CPU执行,所以没有全局解释器锁
web框架 几乎都是多线程
总结:什么是GIL?
- 全局解释器锁
- 由Cpython解释器提供的
- 导致了一个进程中多个线程同一时刻只能有一个线程访问CPU
2 Thread 类
multiprocessing 是完全仿照这threading的类写的
创建线程有两种方式:面向函数、面向对象
线程中的几个方法:
2.1 启动线程 start
不需要写if __name__ = '__main__'
:
1.使用面向函数的方式启动线程
# 开启一个子线程
import os
import time
from threading import Thread
def func():
print('start son thread')
time.sleep(1)
print('end son thread',os.getpid())
Thread(target=func).start()
print('start',os.getpid())
time.sleep(0.5)
print('end',os.getpid())
# 开启多个子线程
def func(i):
print('start son thread',i)
time.sleep(1)
print('end son thread',i,os.getpid())
for i in range(10):
Thread(target=func,args=(i,)).start()
print('main')
2.使用面向对象的方式启动线程
class MyThread(Thread):
def __init__(self,i):
self.i = i
super().__init__()
def run(self):
print('start',self.i,self.ident)
time.sleep(1)
print('end',self.i)
for i in range(10):
t = MyThread(i)
t.start()
print(t.ident)
t.ident 线程的id
2.2 结束进程 join
主线程什么时候结束?
- 主线程等待所有子线程结束之后才结束
- 主线程如果结束了,主进程也就结束了
join方法 阻塞 直到子线程执行结束
def func(i):
print('start son thread',i)
time.sleep(1)
print('end son thread',i,os.getpid())
t_l = []
for i in range(10):
t = Thread(target=func,args=(i,))
t.start()
t_l.append(t)
for t in t_l:t.join()
print('子线程执行完毕')
注意:
- terminate 结束进程
- 在线程中不能从主线程结束一个子线程
2.3 守护线程
t.daemon = True
守护线程一直等到所有的非守护线程都结束之后才结束
除了守护了主线程的代码之外也会守护子线程
非守护线程不结束,主线程也不结束;主线程结束了,主进程也结束。
结束顺序 :非守护线程结束 -->主线程结束-->主进程结束--> 守护线程也结束
import time
from threading import Thread
def son1():
while True:
time.sleep(0.5)
print('in son1')
def son2():
for i in range(5):
time.sleep(1)
print('in son2')
t =Thread(target=son1)
t.daemon = True
t.start()
Thread(target=son2).start()
time.sleep(3)
2.4 threading模块的函数
线程里的一些其他方法:
current_thread 在哪个线程中被调用,就返回当前线程的对象
活着的线程,包括主线程:
- enumerate 返回当前活着的线程的对象列表
- active_count 返回当前或者的线程的个数
from threading import current_thread,enumerate,active_count
def func(i):
t = current_thread()
print('start son thread',i,t.ident)
time.sleep(1)
print('end son thread',i,os.getpid())
t = Thread(target=func,args=(1,))
t.start()
print(t.ident)
print(current_thread().ident) # 水性杨花 在哪一个线程里,current_thread()得到的就是这个当前线程的信息
print(enumerate())
print(active_count()) # =====len(enumerate())
2.5 测试
1.进程和线程的效率都差,但线程的开启、关闭、切换效率比进程的更高。
def func(a,b):
c = a+b
import time
from multiprocessing import Process
from threading import Thread
if __name__ == '__main__':
start = time.time()
p_l = []
for i in range(500):
p = Process(target=func,args=(i,i*2))
p.start()
p_l.append(p)
for p in p_l:p.join()
print('process :',time.time() - start)
start = time.time()
p_l = []
for i in range(500):
p = Thread(target=func, args=(i, i * 2))
p.start()
p_l.append(p)
for p in p_l: p.join()
print('thread :',time.time() - start)
# process : 11.76159143447876
# thread : 0.12466692924499512
2.线程的数据共享的效果
from threading import Thread
n = 100
def func():
global n # 不要在子线程里随便修改全局变量
n-=1
t_l = []
for i in range(100):
t = Thread(target=func)
t_l.append(t)
t.start()
for t in t_l:t.join()
print(n)
注意: 不要在子线程里随便修改全局变量
3 锁
线程中是不是会产生数据不安全?
即便是线程,即便有GIL,也会出现数据不安全的问题。不安全问题存在于以下几种场景:
- 1.操作的是全局变量
- 2.做以下操作:
- += -= *= /+ 先计算再赋值才容易出现数据不安全的问题
- 包括 lst[0] += 1 dic['key']-=1
- 3.多个线程对同一个文件进行写操作
a = 0
def func():
global a
a += 1
import dis
dis.dis(func)
a = 0
def add_f():
global a
for i in range(200000):
a += 1
def sub_f():
global a
for i in range(200000):
a -= 1
from threading import Thread
t1 = Thread(target=add_f)
t1.start()
t2 = Thread(target=sub_f)
t2.start()
t1.join()
t2.join()
print(a)
a = 0
def func():
global a
a -= 1
import dis
dis.dis(func)
加锁会影响程序的执行效率,但是保证了数据的安全。
a = 0
def add_f(lock):
global a
for i in range(200000):
with lock:
a += 1
def sub_f(lock):
global a
for i in range(200000):
with lock:
a -= 1
from threading import Thread,Lock
lock = Lock()
t1 = Thread(target=add_f,args=(lock,))
t1.start()
t2 = Thread(target=sub_f,args=(lock,))
t2.start()
t1.join()
t2.join()
print(a)
线程的锁分为:递归锁 、互斥锁
3.1 互斥锁
互斥锁:在同一个线程中,同一把锁不能连续acquire多次,开销小,产生死锁的几率大。
同一把锁acquire一次就要release一次
from threading import Lock
lock = Lock()
lock.acquire()
print('*'*20)
lock.release()
lock.acquire()
print('-'*20)
lock.release()
两把锁可以同时acquire,如
from threading import Lock
lock1 = Lock()
lock2 = Lock()
lock1.acquire()
print('*'*20)
lock2.acquire()
print('-'*20)
lock1.release()
lock2.release()
3.2 递归锁
递归锁:在一个线程中,同一把锁可以连续多次acquire不会死锁,但acquire多少次就需要release多少次,开销大,一把锁永远不死锁。
from threading import RLock
rlock = RLock()
rlock.acquire()
print('*'*20)
rlock.acquire()
print('-'*20)
rlock.acquire()
print('*'*20)
优点:在同一个线程中多次acquire也不会发生阻塞
缺点:占用了更多资源
3.3 单例模式(多线程)
import time
from threading import Lock
class A:
__instance = None
lock = Lock()
def __new__(cls, *args, **kwargs):
with cls.lock:
if not cls.__instance:
time.sleep(0.1)
cls.__instance = super().__new__(cls)
return cls.__instance
def __init__(self,name,age):
self.name = name
self.age = age
def func():
a = A('alex', 84)
print(a)
from threading import Thread
for i in range(10):
t = Thread(target=func)
t.start()
3.4 死锁现象
<1.> 死锁现象
在某一些线程中,出现陷入阻塞并且永远无法结束阻塞的情况就是死锁现象。
<2.> 死锁现象是怎么发生的?
- 1.有多把锁(一把以上)
- 2.多把锁交替使用
- 3.互斥锁在一个线程中连续acquire
import time
from threading import Thread,Lock
noodle_lock = Lock()
fork_lock = Lock()
def eat1(name,noodle_lock,fork_lock):
noodle_lock.acquire()
print('%s抢到面了'%name)
fork_lock.acquire()
print('%s抢到叉子了' % name)
print('%s吃了一口面'%name)
time.sleep(0.1)
fork_lock.release()
print('%s放下叉子了' % name)
noodle_lock.release()
print('%s放下面了' % name)
def eat2(name,noodle_lock,fork_lock):
fork_lock.acquire()
print('%s抢到叉子了' % name)
noodle_lock.acquire()
print('%s抢到面了'%name)
print('%s吃了一口面'%name)
time.sleep(0.1)
noodle_lock.release()
print('%s放下面了' % name)
fork_lock.release()
print('%s放下叉子了' % name)
lst = ['alex','wusir','taibai','yuan']
Thread(target=eat1,args=(lst[0],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[1],noodle_lock,fork_lock)).start()
Thread(target=eat1,args=(lst[2],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[3],noodle_lock,fork_lock)).start()
<3.> 如何解决死锁现象?
1.递归锁 —— 将多把互斥锁变成了一把递归锁
递归锁本质:只有一把锁
优点:快速解决问题
缺点:效率差
***递归锁也会发生死锁现象,多把锁交替使用的时候
2.优化代码逻辑
优点:
- 可以使用互斥锁解决问题
- 效率相对好
缺点:
- 解决问题的效率相对低(解决问题慢)
# 递归锁解决死锁问题
import time
from threading import RLock,Thread
# noodle_lock = RLock()
# fork_lock = RLock() # 错误写法
noodle_lock = fork_lock = RLock()
print(noodle_lock,fork_lock)
def eat1(name,noodle_lock,fork_lock):
noodle_lock.acquire()
print('%s抢到面了'%name)
fork_lock.acquire()
print('%s抢到叉子了' % name)
print('%s吃了一口面'%name)
time.sleep(0.1)
fork_lock.release()
print('%s放下叉子了' % name)
noodle_lock.release()
print('%s放下面了' % name)
def eat2(name,noodle_lock,fork_lock):
fork_lock.acquire()
print('%s抢到叉子了' % name)
noodle_lock.acquire()
print('%s抢到面了'%name)
print('%s吃了一口面'%name)
time.sleep(0.1)
noodle_lock.release()
print('%s放下面了' % name)
fork_lock.release()
print('%s放下叉子了' % name)
lst = ['alex','wusir','taibai','yuan']
Thread(target=eat1,args=(lst[0],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[1],noodle_lock,fork_lock)).start()
Thread(target=eat1,args=(lst[2],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[3],noodle_lock,fork_lock)).start()
# 互斥锁解决死锁问题
import time
from threading import Lock,Thread
lock = Lock()
def eat1(name,noodle_lock,fork_lock):
lock.acquire()
print('%s抢到面了'%name)
print('%s抢到叉子了' % name)
print('%s吃了一口面'%name)
time.sleep(0.1)
print('%s放下叉子了' % name)
print('%s放下面了' % name)
lock.release()
def eat2(name,noodle_lock,fork_lock):
lock.acquire()
print('%s抢到叉子了' % name)
print('%s抢到面了'%name)
print('%s吃了一口面'%name)
time.sleep(0.1)
print('%s放下面了' % name)
print('%s放下叉子了' % name)
lock.release()
lst = ['alex','wusir','taibai','yuan']
Thread(target=eat1,args=(lst[0],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[1],noodle_lock,fork_lock)).start()
Thread(target=eat1,args=(lst[2],noodle_lock,fork_lock)).start()
Thread(target=eat2,args=(lst[3],noodle_lock,fork_lock)).start()
<4.> 如何避免死锁?
在一个线程中只有一把锁,并且每一次acquire之后都要release
4 队列
线程之间的通信——线程是安全的
1.先进先出队列
写一个server,所有的用户的请求放在队列里——先来先服务的思想
import queue
from queue import Queue # 先进先出队列
q = Queue(3)
q.put(0)
q.put(1)
q.put(2)
print('22222')
print(q.get())
print(q.get())
print(q.get())
2.后进先出队列
与算法相关的(如:递归)
from queue import LifoQueue # 后进先出队列
# last in first out 栈
lfq = LifoQueue(4)
lfq.put(1)
lfq.put(3)
lfq.put(2)
print(lfq.get())
print(lfq.get())
print(lfq.get())
3.优先级队列
优先级队列的好处:
(可以做)自动的排序
抢票的用户级别
如:vip用户在1000-10000之间,普通用户是10001-……,只要是在VIP之间的数就会比普通用户的数优先服务
告警级别
from queue import PriorityQueue
pq = PriorityQueue()
pq.put((10,'alex'))
pq.put((6,'wusir'))
pq.put((20,'yuan'))
print(pq.get())
print(pq.get())
print(pq.get())