并发的基本概念
并发与并行的区别
并行(paralel):同时做某些事,可以互不干扰的同一时刻做几件事
并发(concurrency):同时做某些事,但是强调一个时间段内有事情要处理
举例:
乡村公路上一条车道,半边路面发生坍塌,交警指挥交通,众多车辆要在这一时段内要通过路面的时间,就是并发
高速公路的上的双向4车道,所有车辆可以互不干扰的在自己车道上互不干扰的奔跑,在同一个时刻,每条车道上了能同时存在有车辆在行驶,是同时发生的,这就是并行
并发的解决
食堂打饭模型
中午12点,开饭了,大家都永祥食堂,这就是并发,如果人很多,就是高并发
1、队列,缓冲区
假设只有一个窗口,陆续涌入食堂的人,排队打饭是比较好的方式
所以排队(队列)是一种天然的解决并发的方法
排队就是把人排成队列,先进先出,解决了资源使用的问题
排成的队列,其实就是一个缓冲的地带,就是缓冲区
把要处理的数据排成一个队列,其实就是一个缓冲地带,缓冲区
例如queue模块的类Queue、LifoQueue、PriorityQueue
2、争抢
只开一个窗口,有可能没有秩序,也就是谁挤进去就给谁打饭。挤到窗口的人占据窗口,直到打到饭菜离开
其他人继续争抢,会有一个人占据窗口,可以视为锁定窗口,窗口就不能为其他人提供服务了,这是一种锁机制,谁抢到资源就上锁,排他性的锁,其他人只能等待
争抢也是一种解决高并发的方案,但是这样不好,因为可能有人很长时间都抢不到
3、预处理
如果排长队的原因是由于每个人打菜等候时间长,因为要吃的菜没有,需要现做,没打到饭不走开,锁定着窗口
食堂可以提前统计大多数人最爱吃的菜品,将最爱吃的80%的热门菜,提前做好,保证供应
这样大多数人,就算锁定窗口,也很快就释放窗口了
一种提前加载用户需要的数据的思路,缓存用的就是预处理思想
4、并行
成百上千的人同时来吃饭,一个队伍搞不定的,多开打饭窗口形成多个队列,如同多开车道一样,并行打菜
开窗口就得扩大食堂,得多雇人在每个窗口上提供服务,造成成本上升
日常可以通过购买更多服务器,或多开进程,线程实现并行处理,来解决并发问题
注意这些都是水平扩展思想
注:如果线程在单CPU上处理,就不是并行
但是多数服务器都是多CPU的,服务部署往往是多机的,分布式的,这都是并行处理
5、提速
提高单个窗口的打饭速度,也是解决并发的方式
打饭人员提高工作技能,或为单个窗口配置更多的服务人员,都是提速的方法
提高单个CPU的性能,或单个服务器安装更多的CPU
这是一种垂直扩展的思想
6、消息中间件
北京的上地,西二旗地铁站外的九曲回肠的走廊,缓冲人流,进去之后再多个安检进站
常见的消息中间件有RabbitMQ、ActiveMQ(Apache)、RocketMQQ(阿里Apache)、kafka(Apache)等
当然还有其它手段解决并发问题,但是已经列举了最常用的解决方案,一般来说不同的并发场景应用不同的策略,而策略可能是多种方式的组合
例如多开食堂(多地),也可以把食堂建设到宿舍生活区(就近),所以说,计数来源于生活
进程和线程
在实现了线程的操作系统中,线程是操作系统能够进行运算调度的最小单位,它被包含在进程之中,是进程的实际运作单位,一个程序的执行实例就是一个进程
进程:计算机中的程序关于某数据集合上的依次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础
Linux进程有父进程、子进程,Windows的进程是平等关系
线程:程序执行流的最小单元,有时也被称为轻量级进程(Lightweight Process,LWP)
一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成
在许多系统中,创建一个线程比创建一个进程快10-100倍
进程、线程的理解
现代操作系统中提出进程的概念,每一个进程都认为自己独占所有的计算机硬件资源
进程就是独立的王国,进程间不可以随便的共享数据
线程就好像是省份,同一个进程内的线程是可以共享进程的资源,每一个线程拥有自己独立的堆栈
线程的状态
状态 | 含义 |
---|---|
就绪(Ready) | 线程能够运行,但在等待被调度,可能线程刚刚创建启动,或刚刚从阻塞中恢复,或者被其他线程抢占 |
运行(Running) | 线程正在运行 |
阻塞(Rlocked) | 线程等待外部事件发生而无法运行,如I/O操作 |
终止(Terminated) | 线程完成或退出,或被取消 |
Python中的线程开发
Python的线程开发使用threading
Thread类
签名
def __int__(self,group=None,target=None,name=None,args=(),kwargs=None,*,daemon=None)
参数名 | 含义 |
---|---|
target | 线程调用的对象,就是函数目标 |
name | 为线程起个名字 |
args | 为目标函数传递实参,元组 |
kwargs | 为目标函数关键字传参,字典 |
线程启动
import threading
#最简单的线程程序
def worker():
print('I am working')
print('Finished')
t = threading.Thread(target=worker,name='worker') #线程对象
t.start() #启动
通过threading.Thread创建一个线程对象,target是目标函数,那么可以制定名称。
但是线程没有启动,需要调用start方法
线程之所以执行函数,是因为线程中就是执行代码的,而最简单的的封装就是函数,所以还是函数调用
函数执行完,线程也就退出了
那么,如果不让线程退出,或者让线程一直工作怎么办呢?
import threading
import time
def worker():
while True: #增加一个死循环
time.sleep(1)
print('I am working')
pritn('Finished')
t = threading.Thread(target=worker,name='worker')
t.start()
线程退出
Python没有提供线程退出的方法,线程在下面的情况时会退出
1、线程函数内语句执行完毕
2、线程函数中抛出未处理的异常
import threading
import time
def worker():
count = 0
while True:
if count > 5:
#raise RuntimeError(count)
#return
break
time.sleep(1)
print('I am working')
count += 1
t = threading.Thread(target=worker,name='worker')
t.start()
Python的线程没有优先级,没有线程组的概念,也不能销毁、停止、挂起
线程的传参
import threading
import time
def add(x,y):
print('{} + {} = {}'.format(x,y,x+y,threading.current_thread().ident))
t1 = threading.Thread(target=add,name='add',args=(4,5))
t1.start()
time.sleep(2)
t2 = threading.Thread(target=add,name='add',args=(5,),kwargs={'y':4})
t2.start()
time.sleep(2)
t3 = threading.Thread(target=add,name='add',kwargs{'x':4,'y':5})
t.start()
线程的传参和函数传参没有区别,本质上就是函数传参。
threading的属性和方法
名称 | 含义 |
---|---|
current_thread() | 返回当前线程对象 |
main_thread() | 返回主线程对象 |
active_count() | 处于alive状态的线程个数 |
enumerate() | 返回所有活着的线程列表,不包括已经终止的线程和未开始的线程 |
get_indent() | 返回当前线程的ID,非0整数 |
active_count,enumerate方法返回的值还包括主线程
import threading
import time
def showthreadinfo():
print('currentthread = {}'.format(threading.current_thread()))
print('main thread = {}'.format(threading.main_thread()))
print('active count = {}'.format(threading.active_count()))
def worker():
count = 0
showthreadinfo()
while True:
if count > 5:
break
time.sleep(1)
count += 1
print('I am working')
t = threading.Thread(target=worker,name='worker')
showthreadinfo()
t.start()
print('===End===')
Thread实例的属性和方法
名称 | 含义 |
---|---|
name | 只是一个名字,只是个标识,名称可以重名,getName()、setName()获取、设置这个名词 |
ident | 线程ID,它是非0的整数。线程启动后才会有ID,否者为None.线程退出,此ID依旧可以访问,可以重复使用 |
is_alive() | 返回线程是否还在运行 |
注意:线程的name是一个名称,可以重复。ID必须唯一,但可以在线程退出后再利用
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(1)
count += 1
print(threading.current_thread().name)
t = threading.Thread(target=worker,name='worker')
print(t.ident)
t.start()
while True:
time.sleep(1)
if t.is_alive():
print('{} {} alive'.format(t.name,t.ident))
else:
print('{} {} dead'.format(t.name,t.ident))
名称 | 含义 |
---|---|
start() | 启动线程,每一个线程必须且只能执行一次该方法 |
run() | 运行线程函数 |
start方法
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(1)
count += 1
print('worker running')
class MyThread(threading.Thread):
def start(self):
print('start-----------')
super().start() #调用父类的start方法
def run(self):
print('run-------------')
super().run()
t = MyThread(target=worker,name='worker')
t.start()
#运行结果
start------------
run-----------
worker running
run方法
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(1)
count += 1
print('worker running')
class MyThread(threading.Thread):
def start(self):
print('start-----------')
super().start() #调用父类的start方法
def run(self):
print('run-------------')
super().run()
t = MyThread(target=worker,name='worker')
t.run()
#运行结果
run-------------
worker running
start()方法会调用run()方法,而run()方法可以运行函数。
这两个方法看是功能重复了,name留一个方法就可以了,是这样吗?
start和run的区别
在线程函数中,增加打印线程名字的语句,看看能看到什么信息
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(1)
count += 1
print('worker running')
print(threading.current_thread().name)
class MyThread(threading.Thread):
def start(self):
print('start-----------')
super().start() #调用父类的start方法
def run(self):
print('run-------------')
super().run()
t = MyThread(target=worker,name='worker')
t.start()
#t.run() 分别执行start和run方法,看看区别
使用start方法启动线程,启动了一个新的线程,名字叫做worker,但是使用run方法,并没有启动新线程,就是在主线程中调用了一个普通的函数而已。
因此,启动线程请使用start方法,才能启动多个线程
多线程
顾名思义,一个进程中如果有多个线程,就是多线程,实现一种并发
import threading
import time
def worker():
count = 0
while True:
if count > 5:
break
time.sleep(1)
count += 1
print('worker running')
print(threading.current_thread().name,threading.current_thread().ident)
class MyThread(threading.Thread):
def start(self):
print('start-----------')
super().start()
def run(self):
print('run-------------')
super().run()
t1 = MyThread(target=worker,name='worker1')
t2 = MyThread(target=worker,name='worker2')
t1.start()
t1.start()
#t1.run()
#t2.run()
可以看出start方法worker1和worker2交替执行
而使用run方法没有开新线程,就是普通的函数调用那个,执行完t1.run(),然后执行t2.run(),这就不是多线程
当start()方法启动线程后,进程内有多个活动的线程并行的工作,就是多线程
一个进程中至少有一个线程,并作为程序的入口,这个线程就是主线程。一个进程至少有一个主线程,其他线程称为工作线程
线程安全
IPython中演示,python命令行,pycharm都不能演示出效果
import threading
def woker():
for x in range(100):
print('{} is running'.format(threading.current_thread().name))
for x in range(1,5):
name = 'worker{}'.format(x)
t = threading.Thread(target=worker,name=name)
t.start()
运行以上代码,查看运行结果可以发现很多字符串打在了一起,不应该是一行行打印吗?这是为什么呢?
这就说明print函数在执行过程中被线程切换打断了。print函数执行分两步,第一步打印字符串,第二部换行,就在这之间,发生了线程的切换,导致了这种情况,print函数是线程不安全的
线程安全:线程执行一段代码,不会产生不确定的结果,那这段代码就是线程安全
上例中,本以为print应该是打印文本之后紧跟着一个换行的,但是有时候确实好几个文本在一起,后面跟上换行,而且发生这种情况的时机不确定,所以,print函数不是线程安全函数
如果是这样,多线程编程时,print输出日志,不能保证一个输出一定后面立即换行,怎么办?
1.不让print打印换行
import threading
def woker():
for x in range(100):
print('{} is running'.format(threading.current_thread().name),end='') #不让print函数换行打印
for x in range(1,5):
name = 'worker{}'.format(x)
t = threading.Thread(target=worker,name=name)
t.start()
字符串是不可变类型,它可以作为一个整体不可分割输出,end=”就不让print输出换行了
2.使用logging
import threading
def woker():
for x in range(100):
logging.warning('{} is running'.format(threading.current_thread().name))
for x in range(1,5):
name = 'worker{}'.format(x)
t = threading.Thread(target=worker,name=name)
t.start()
daemon线程和non-daemon线程
注意:这里的daemon不是Linux中的守护进程
进程靠线程执行代码,至少有一个主线程,其它线程是工作线程
主线程是第一个启动的线程
父线程:如果线程A中启动了一个线程B,A就是B的父线程
子线程:B就是A的子线程
Python中,构造线程的时候可以设置daemon属性,这个属性必须在start方法之前设置好
#源码Thread的__init__方法中
if daemon is not None:
self._daemonic = daemon #用户设定bool值
else:
self._daemonic = current_thread().daemon
self._ident = None
线程daemon属性,如果设定就是用户的设置,否则就去当前线程的daemon值
主线程时non-daemon 线程,即daemon = False
import time
import threading
def foo():
time.sleep(5)
for i in range(20):
print(i)
#主线程是non-daemon线程
t = threading.Thread(target=foo,daemon=False)
t.start()
print('Main Thread Exiting')
发现线程t依然执行,主线程已经执行完,但是一直等着线程 t
修改为 t = threading.Thread(target=foo,daemon=True)试一试
程序立即结束了,根本没有等线程t
名称 | 含义 |
---|---|
daemon属性 | 表示线程是否是daemon线程,这个值必须在start()之前设置,否者引发RuntimeError异常 |
isDaemon() | 是否是daemon线程 |
setDaemon() | 设置为daemon线程,必须在start方法之前设置 |
总结:
线程具有一个daemon属性,可以显示设置为True或False,也可以不设置,取默认值None
如果不设置daemon,就取当前线程的daemon来设置它
主线程时non-daemon线程,即daemon= False
从主线程创建的所有线程不设置daemon属性,则都默认daemon = False,也就是non-daemon线程
Python程序在没有活着的non-daemon线程运行时退出,也就是剩下的只能是daemon线程,主线程才能退出,否则主线程只能等待。
思考下面的程序的输出时是什么?
import time
import threading
def bar():
time.sleep(10)
print('bar')
def foo():
for i in range(20):
print(i)
t =threading.Thread(target=bar,daemon=False)
t.start()
#主线程是non-daemon线程
t= threading.Thread(target=foo,daemon=True)
t.start()
print('Main Thread Exiting')
上例中,会不会输出bar这个字符串?如果没有,如何修改才能打印出来呢?
time。sleep(2)
print('Main Thread Exiting')
在主线程print函数前加个延时语句
再看一个例子,看看主线程合适结束daemon线程
imprt time
import threading
def foo():
for i in range(10):
print(i)
time.sleep(1)
t = threading.Thread(target=foo,args=(10,),daemon=True) #调换10和20看看效果
t2.start()
t2 = threading.Thread(target=foo,aegs=(20,),daemon=False)
time.sleep(2)
print('Main Thread Exiting')
上例说明,如果有non-daemon线程的时候,主线程退出时,也不会结束所有的daemon,直到所有non-daemon线程全部结束,如果还有daemon线程,主线程需要要退出时,会结束所有daemon线程,退出
join方法
先看一个简单的例子,看看效果
import time
import threading
def foo(n):
for i in range(n):
print(i)
time.sleep(1)
t1 = threading.Thread(target=foo,args=(10,),daemon=True)
t1.start()
t1.join() #设置join,取消join对比一下
print('Main Thread Exiting')
使用了join方法后,daemon线程执行完了,主线程才退出了
join(timeout=None),是县城的标准方法之一
一个线程中调用另一个线程的join方法,调用者将被阻塞,直到被调用线程结束
timeout参数指定调用者需要等待多久,没有设置超时时,就一直等到被调用线程执行完结束
调用谁的join方法,就是join谁,就要等谁
daemon线程应用场景
简单来说,本来并没有daemon线程,为了简化程序员的工作,让他们不用去记录和管理那些后台线程,创造了以个daemon线程的概念,这个概念唯一的作用就是,当你把一个线程设置为daemon线程,它会随着主线程的退出而退出
主要应用场景:
1.后台任务,如发送心跳包、监控,这种场景最多
2.主线程工作采用那个用的线程,如主线程中维护着公共的资源,主线程已经清理了,准备退出,而工作线程使用这些资源,那工作也就没有意义了,一起退出最合适
3.随时可以被终止的线程
如果主线程退出,想所有其它工作线程一起退出,就是用daemon=True来创建线程
比如,开启一个线程定时判断WEB服务是否正常工作,主线程退出,工作线程也就没有必要了,应该随着主线程退出一起退出。这种daemon线程一旦创建,就可以忘记它了,只用关心主线程什么时候退出就行了
daemon线程简化了程序员手动关闭线程的工作
如果non-daemon线程A中,对另一个daemon线程B使用了join方法,那么线程B设置成daemon线程就没有什么意义了,因为non-daemon线程A总是要等待B
如果在一个daemon线程C中,对另一个daemon线程D使用了join方法,只能说明C要等待D,主线程退出,C和D不管是否结束,也不管它们谁等谁,都要被强制结束
举例
import time
import threading
def bar():
while True:
time.sleep(1)
print('bar')
def foo():
print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
t2 = threading.Thread(target=bar)
t2.start()
print("t2's daemon = {}".fromat(t2.isDaemon()))
t1 = threading.Thread(target=foo,daemon=True)
t1.start()
time.sleep(2)
print('Main Thread Exiting')
上例,只要主线程退出,2个工作线程都结束
可以使用join,让线程结束不了,怎么做?
import time
import threading
def bar():
while True:
time.sleep(1)
print('bar')
def foo():
print("t1's daemon = {}".format(threading.current_thread().isDaemon()))
t2 = threading.Thread(target=bar)
t2.start()
print("t2's daemon = {}".fromat(t2.isDaemon()))
t2.join() #
t1 = threading.Thread(target=foo,daemon=True)
t1.start()
t1.join() #
time.sleep(2)
print('Main Thread Exiting')
threading.local类
import time
import threading
def worker():
x = 0
for i in range(100):
time.sleep(0.0001)
x += 1
print(threading.current_thread(),x)
for i in range(10):
threading.Thread(target=worker).start()
上例使用多线程,每个线程完成不同的计算任务,x是局部变量,能否改造成使用全局变量完成
import time
import threading
class A:
def __init__(self):
self.x = 0
global_data = A()
def worker():
global_data.x = 0
for i in range(100):
time.sleep(0.0001)
global_data.x += 1
print(threading.current_thread(),global_data.x )
for i in range(10):
threading.Thread(target=worker).start()
运行还是上面的代码可以看出上例虽然使用了全局变量,但是线程之间互相干扰,导致了错误的结果。
能不能使用全局变量,还能保证每个线程使用不同的数据呢?
Python提供threading.local类,将这个类实例化得到一个全局对象,但是不同线程使用这个对象储存的数据其他线程看不见
import time
import threading
class A:
def __init__(self):
self.x = 0
global_data = threading.local()
def worker():
global_data.x = 0
for i in range(100):
time.sleep(0.0001)
global_data.x += 1
print(threading.current_thread(),global_data.x )
for i in range(10):
threading.Thread(target=worker).start()
结果显示和使用局部变量的效果一样
再看看threading.local的例子
import threading
X = 'abc'
ctx = threading.local()
ctx.x = 123
print(ctx,type(ctx),ctx.x)
def worker():
print(X)
print(ctx)
print(ctx.x)
print('working')
worker()
print('-----------')
threading.Thread(target=worker).start() #另起一个线程
从运行结果来看,另起一个线程打印ctx.x出错了
AttributeError: '_thread._local' object has no attribute 'x'
但是,ctx打印没有出错,说明看到了ctx,但是ctx中的x看不到,这个x不能跨线程
threading.local类构建了一个大字典,其元素时每个线程实例的地址为key和线程对象引用线程单独的字典的映射,如下:
{id(Thrread) -> (ref(Thread),thread-local dict)}
通过threading.local实例就可在不同的线程中,安全地使用线程独有的数据,做到了线程间数据隔离,如同本地变量一样安全
定时器Timer/延迟执行
threading.Timer继承自Thread,这个类用来定义多久执行一个函数
class thread.Timer(interval,function,arg=None,kwargs=None)
start方法执行之后,Timer对象会处于等待状态,等待了interval之后,开始执行function函数
如果在执行函数之前的等待阶段,使用了cancel方法,就会跳过执行函数结束
import threading
import logging
import time
FORMAT = '%(asctime)s %(threadname)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker():
logging.info('in worker')
time.sleep(2)
t = threading.Timer(5,worker)
t.setName('worker1')
t.start()
print(threading.enumerate())
t.cancel() #取消,可以注释这一句看看如何定时执行
tim.sleep(1)
print(threading.enumerate())
如果线程worker函数已经开始执行,cancel就没有任何效果了
总结:
Timer是线程Thread的子类,就是线程类,具有线程的能力和特征
他的实例时能够延时执行目标函数的线程,在真正执行函数之前,都可以cancel它
import threading
import logging
import time
FORMAT = '%(asctime)s %(threadname)s %(thread)d %(message)s'
logging.basicConfig(format=FORMAT,level=logging.INFO)
def worker():
logging.info('in worker')
time.sleep(2)
t = threading.Timer(5,worker)
t.setName('worker1')
t.cancel() #提前取消
t.start()
print(threading.enumerate())
tim.sleep(8)
print(threading.enumerate())