1. 并发
1.1 并发的基本概念
1.1.1 并发和并行的区别
并行,parallel
同时做某些事,可以互不干扰的同一时刻做几件事。
并发,concurrency
也是同时做某些事,但是强调,一个时段内有事情要处理。
1.1.2 并发的解决
食堂打饭模型:
队列、缓冲区(buffering)
争抢
预处理(缓存)
并行(水平扩展思想)
提速(垂直扩展思想)
提高单个CPU性能,或单个服务器安装更多的CPU
消息中间件
常见的消息中间件有RabbitMQ、ActiveMQ(Apache)、RocketMQ(阿里Apache)、kafka(Apache)等
2. 进程和线程
在实现了线程的操作系统中,线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位。一个程序的执行实例就是一个进程。
进程(Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础。Linux进程有父进程、子进程,Windows的进程是平等关系。
2.1 进程和程序的关系
程序是源代码编译后的文件,而这些文件存放在磁盘上。当程序被操作系统加载到内存中,就是进程,进程中存放着指令和数据(资源),它也是线程的容器。
线程,有时被称为轻量级进程(Lightweight Process,LWP),是程序执行流的最小单元。一个标准的线程由线程ID,当前指令指针(PC),寄存器集合和堆栈组成。在许多系统中,创建一个线程比创建一个进程快10-100倍。
2.1.1 进程与线程的理解
现代操作系统提出进程的概念,每一个进程都认为自己独占所有的计算机硬件资源。
进程就是独立的国家,进程间不可以随便的共享数据。
线程就是省份,同一个进程内线程可以共享进程的资源,每一个线程拥有自己独立的堆栈。(线程之间的数据也是不能共享的)
2.2 线程的状态
2.2.1 python中的进程和线程
进程会启动一个解释器进程,线程共享一个解释器进程。
2.3 python的线程开发
python的线程开发使用标准库threading
2.3.1 Thread类
def __init__(self, group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
import threading
# 最简单的线程程序
def worker():
print("I'm working")
print('Fineshed')
t = threading.Thread(target=worker, name='worker') # 线程对象
t.start() # 启动
通过threading.Thread创建一个线程对象,target是目标函数,name可以指定名称。但是线程没有启动,需要调用start方法。线程之所以执行函数,是因为线程中就是执行代码的,而最简单的封装就是函数,所以还是函数调用。函数执行完,线程也就退出了。
那么,如果不让线程退出,或者让线程一直工作怎么办呢?
import threading
import time
def worker():
while True:
time.sleep(1)
print("I'm working")
print('Fineshed')
t = threading.Thread(target=worker, name='worker') # 线程对象
t.start() # 启动
线程退出: python没有提供线程退出的方法,线程在下面情况时退出
- 线程函数内的语句执行完毕
- 线程函数中抛出未处理的异常
python的线程没有优先级、没有线程组的概念,也不能被销毁、停止、挂起,那也就没有恢复、中断了。
线程传参:
import threading
import time
def add(x, y):
print('{} + {} = {}'.format(x, y, x + y, threading.current_thread().ident))
thread1 = threading.Thread(target=add, name='add', args=(4, 5)) # 线程对象
thread1.start() # 启动
time.sleep(2)
thread2 = threading.Thread(target=add, name='add', args=(5,), kwargs={'y': 4}) # 线程对象
thread2.start() # 启动
time.sleep(2)
thread3 = threading.Thread(target=add, name='add', kwargs={'x': 4, 'y': 5}) # 线程对象
thread3.start() # 启动
线程传参和函数传参没什么区别,本质上就是函数传参。
threading的属性和方法:
active_count、enumerate()方法返回的值还包括主线程。
import threading
import time
def show_thread_info():
print("current_thread = {}".format(threading.current_thread()))
print("main thread = {}".format(threading.main_thread()))
print("active_count = {}".format(threading.active_count()))
def worker():
count = 0
show_thread_info()
while True:
if count > 3:
break
time.sleep(1)
print("I'm working")
count += 1
t = threading.Thread(target=worker, name='worker') # 线程对象
show_thread_info()
t.start() # 启动
print('==End==')
"""\
current_thread = <_MainThread(MainThread, started 1744)>
main thread = <_MainThread(MainThread, started 1744)>
active_count = 1
current_thread = <Thread(worker, started 8888)>
==End==
main thread = <_MainThread(MainThread, started 1744)>
active_count = 2
I'm working
I'm working
I'm working
I'm working
"""
Thread实例的属性和方法:
注意:线程的name这是一个名称,可以重复;ID必须唯一,但可以在线程退出后再利用
注意:每一个线程必须且只能执行start()方法一次
2.4 多线程
顾名思义,多个线程,一个进程中如果有多个线程,就是多线程,实现一种并发。一个进程中至少有一个线程,并作为程序的入口,这个线程就是主线程。一个进程至少有一个主线程,其他线程称为工作线程。
2.4.1 线程安全
线程安全
线程执行一段代码,不会产生不确定的结果,那这段代码就是线程安全的。
import threading
def worker():
for x in range(100):
print('{} is running'.format(threading.current_thread().name))
for i in range(5):
name = 'worker{}'.format(i + 1)
t = threading.Thread(target=worker, name=name)
t.start()
注意:IPython中演示、python命令行、pycharm都不能演示出效果
看代码,应该是一行行打印,但是很多字符串打在了一起,为什么?
说明,print函数被打断了,被线程切换打断了。print函数分两步,第一步打印字符串,第二步换行,就在这之间,发生了线程的切换。这说明print函数是线程不安全的。
那么问题来了,多线程编程的时候,print输出日志,不能保证一个输出一定后面立即换行了,怎么办?
- 不让print打印换行,直接将end设置为空
import threading
def worker():
for x in range(100):
print('{} is running'.format(threading.current_thread().name), end='')
for i in range(5):
name = 'worker{}'.format(i + 1)
t = threading.Thread(target=worker, name=name)
t.start()
- 使用logging
标准库里面的logging模块,日志处理模块,线程安全,生成环境代码都使用logging
import threading
import logging
FORMAT = '%(asctime)s %(threadName)s %(thread)d %(message)s' # 注意%后不能有空格,C语言风格
logging.basicConfig(format=FORMAT, level=logging.INFO)
def worker():
for x in range(100):
logging.info('{} is running'.format(threading.current_thread().name), end='')
for i in range(5):
name = 'worker{}'.format(i + 1)
t = threading.Thread(target=worker, name=name)
t.start()
2.4.2 daemon线程和non-daemon线程
注意:这里的daemon不是linux中的守护线程
进程靠线程执行代码,至少有一个主线程,其它线程是工作线程。主线程是第一个启动的线程。父线程:如果线程A中启动了一个线程B,A就是B的父线程。子线程:B就是A的子线程。Python中,构造线程的时候,可以设置daemon属性,这个属性必须在start方法前设置好。
线程daemon属性,如果设定就是用户的设置,否则就取当前线程的daemon值。主线程是non-daemon线程,即daemon = False。
import time
import threading
def foo():
time.sleep(2)
for i in range(3):
print(i)
# 主线程是non-daemon线程
t = threading.Thread(target=foo, daemon=False)
t.start()
print('Main Thread Exiting')
"""\
Main Thread Exiting
0
1
2
"""
发现线程t依然执行,主线程已经执行完,但是一直等着线程t。修改为 t = threading.Thread(target=foo, daemon=True) 试一试?程序立即结束了,根本没有等线程t。
总结
线程具有一个daemon属性,可以显示设置为True或False,也可以不设置,则取默认值None。如果不设置daemon,就取当前线程daemon来设置它。主线程是non-daemon线程,即daemon = False。从主线程创建的所有线程的不设置daemon属性,则默认都是daemon = False,也就是non-daemon线程。Python程序在没有活着的non-daemon线程运行时退出,也就是剩下的只能是daemon线程,主线程才能退出,否则主线程就只能等待。
import time
import threading
def foo(n):
for i in range(n):
print(i)
time.sleep(1)
t1 = threading.Thread(target=foo, args=(2,), daemon=True) # 调换10和20看看效果
t1.start()
t2 = threading.Thread(target=foo, args=(5,), daemon=False) # 主线程会等到此线程结束再退出
t2.start()
time.sleep(2) # 主线程睡2秒钟
print('Main Thread Exiting')
"""\
0
0
1
1
Main Thread Exiting
2
3
4
"""
上例说明,如果有non-daemon线程的时候,主线程退出时,也不会杀掉所有daemon线程,直到所有nondaemon线程全部结束,如果还有daemon线程,主线程需要退出,会结束所有daemon线程,退出。
2.4.3 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() # 会让主线程等t1这个工作线程,主线程会卡在这里,直到t1工作线程结束
print('Main Thread Exiting') # 有了join方法后,此语句会最后打印
使用了join方法后,daemon线程执行完了,主线程才退出了。join(timeout=None),是线程的标准方法之一。一个线程中调用另一个线程的join方法,调用者将被阻塞,直到被调用线程终止。一个线程可以被join多次。timeout参数指定调用者等待多久,没有设置超时,就一直等到被调用线程结束。调用谁的join方法,就是join谁,就要等谁。
2.4.4 daemon线程应用场景
简单来说就是,本来并没有 daemon thread,为了简化程序员的工作,让他们不用去记录和管理那些后台线程,
创造了一个 daemon thread 的概念。这个概念唯一的作用就是,当你把一个线程设置为 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) # 默认取t1线程设置的daemon值,即True,但是有join方法,所以t1线程会等待t2线程
t2.start()
print("t2's daemon = {}".format(t2.isDaemon()))
t2.join(2) # 会死循环,因为t1线程一直要等t2线程,而t2线程函数是死循环,可以设置等待时间
t1 = threading.Thread(target=foo, daemon=True)
t1.start()
t1.join() # 主线程会卡在这里
time.sleep(3) # 会让主线程沉睡3秒,会继续执行线程t2
print('Main Thread Exiting')
"""\
t1's daemon = True
t2's daemon = True
bar
bar
bar
bar
bar
Main Thread Exiting
"""
2.4.5 threading.local类
import threading
import time
# 局部变量实现
def worker():
x = 0
for i in range(100):
time.sleep(0.0001)
x += 1
print(threading.current_thread(), x)
for _ in range(10):
threading.Thread(target=worker).start()
上例使用多线程,每个线程完成不同的计算任务。x是局部变量,可以看出每一个线程的x是独立的,互不干扰的,为什么?每个线程函数都需要压栈,并且都是独立的,x为局部变量就是说每个线程函数都使用局部的x,所以会互不干扰
那么问题来了,能否改造成使用全局变量完成?
因为多线程之间相互干扰,会导致出现不期望的结果。那么能不能使用全局对象,还能保持每个线程使用不同的数据呢?python提供了threading.local类,将这个类实例化得到一个 全局对象,但是不同的线程使用这个对象存储的数据其他线程看不到。
import threading
import time
# 全局对象
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 _ in range(5):
threading.Thread(target=worker).start()
"""\
<Thread(Thread-5, started 4904)> 100
<Thread(Thread-1, started 8232)> 100
<Thread(Thread-2, started 8564)> 100
<Thread(Thread-3, started 8360)> 100
<Thread(Thread-4, started 5360)> 100
"""
再来看一个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()
# 开启一个新的线程,此时线程函数worker中的ctx.x就会报错,因为此线程看不到主线程中ctx.x的值
# AttributeError: '_thread._local' object has no attribute 'x'
从运行结果来看,另起一个线程打印ctx.x出错了。AttributeError: ‘_thread._local’ object has no attribute ‘x’,但是,ctx打印没有出错,说明看到ctx,但是ctx中的x看不到,这个x不能跨线程。
threading.local类构建了一个大字典,存放所有线程相关的字典,定义如下:
{ id(Thread) -> (ref(Thread), thread-local dict) }
每一线程实例的id为key,元组为value。value中2部分为,线程对象引用,每个线程自己的字典。
2.4.6 定时器Timer/延迟执行
threading.Timer继承自Thread,这个类用来定义延迟多久后执行一个函数。
class threading.Timer(interval, function, args=None, kwargs=None)
start方法执行之后,Timer对象会处于等待状态,等待了interval秒之后,开始执行function函数的。
import threading
import logging
import time
FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(level=logging.INFO, format=FORMAT)
def worker():
logging.info('in worker')
time.sleep(2) # 2秒之后当前线程接结束,主线程也结束了
count = 0
t = threading.Timer(4, worker)
t.setName('timer')
# t.cancel() # 此位置会取消线程,线程timer都没有机会启动
t.start()
# t.cancel() # 此位置会取消线程函数的执行,注意线程timer已经启动了
while count < 3:
print(threading.enumerate()) # 列出当前活着的线程
time.sleep(1)
count += 1
Timer提供了cancel方法,用来取消一个未执行的函数,如果上面例子中worker函数已经开始执行,cancel就没有任何效果了。
总结:
Timer是线程Thread的子类,就是线程类,具有线程的能力和特征。它的实例是能够延时执行目标函数的线程,在真正执行目标函数之前,都可以cancel它。cancel方法本质使用Event类实现。这并不是说,线程提供了取消的方法。