我们要创建Thread对象,然后让他们运行,每个Thread对象代表一个线程,在每个线程中我们可以让程序处理不同的任务,这就是多线程编程。
创建Thread对象有两种方法:
1.直接创建Thread,将一个callable对象从类的构造器传递出去,这个callable就是回调函数,用来处理任务。
2.编写一个自定义类继承Thread,然后复写run()方法,在ru()方法中编写任务处理代码,然后创建Thread的子类。
1.直接创建Thread对象
# 导入Python标准库中的Thread模块
from threading import Thread
# 创建一个线程
mthread = threading.Thread(target=function_name, args=(function_parameter1, function_parameterN))
# 启动刚刚创建的线程
mthread .start()
参数说明:
function_name: 需要线程去执行的方法名
args: 线程执行方法接收的参数,该属性是一个元组,如果只有一个参数也需要在末尾加逗号
Thread类定义了以下常用方法与属性:
方法与属性 | 说明 |
---|---|
start() | 启动线程,等待CPU调度 |
run() | 线程被cpu调度后自动执行的方法 |
getName()、setName() | 用于获取和设置线程的名称 |
setDaemon() | 设置为后台线程或前台线程(默认是False,前台线程)。如果是后台线程,主线程执行过程中,后台线程也在进行,主线程执行完毕后,后台线程不论成功与否,均停止。如果是前台线程,主线程执行过程中,前台线程也在进行,主线程执行完毕后,等待前台线程执行完成后,程序才停止 |
ident | 获取线程的标识符。线程标识符是一个非零整数,只有在调用了start()方法之后该属性才有效,否则它只返回None |
is_alive() | 判断线程是否是激活的(alive)。从调用start()方法启动线程,到run()方法执行完毕或遇到未处理异常而中断这段时间内,线程是激活的 |
isDaemon()方法和daemon属性 | 是否为守护线程 |
join([timeout]) | 调用该方法将会使主调线程堵塞,直到被调用线程运行结束或超时。参数timeout是一个数值类型,表示超时时间,如果未提供该参数,那么主调线程将一直堵塞到被调线程结束 |
1)创建多线程
Thread的构造方法中,最重要的参数是target,所以我们需要将一个callable对象赋值给它,线程才能正常运行。
如果要让一个Thread对象启动,调用它的start()方法即可。
import threading
import time
def test():
for i in range(5):
print('The {} child thile '.format(i))
time.sleep(1)
thread = threading.Thread(target=test)
thread.start()
# thread.join()
for i in range(5):
print('The {} main thile '.format(i))
time.sleep(1)
上面代码很简单,在主线程上打印 5 次,在一个子线程上打印 5 次。
The 0 child thile The 0 main thile
The 1 child thile The 1 main thile
The 2 child thile
The 2 main thile
The 3 main thile The 3 child thile
The 4 child thile
The 4 main thile
上面的 callable 没有参数,如果需要传递参数的话,args 是固定参数,kwargs 是可变参数。
2)Thread的名字
每一个Thread都有一个name的属性,代表的就是线程的名字,这个可以在构造方法中赋值。如果在构造方法中没有为name赋值的话,默认就是“Thread-N”的形式,N是数字。
import threading
import time
def test():
for i in range(5):
print(threading.current_thread().name+" test ",i)
time.sleep(1)
thread=threading.Thread(target=test)
thread.start()
for i in range(5):
print("This is "+threading.current_thread().name+"main ",i)
time.sleep(1)
输出为:
Thread-1 test This is MainThreadmain 00
Thread-1 test 1
This is MainThreadmain 1
Thread-1 test 2
This is MainThreadmain 2
This is MainThreadmain 3Thread-1 test
3
Thread-1 test 4
This is MainThreadmain 4
在Thread对象创建时,给name赋值
thread = threading.Thread(target=test,name='aoligei')
运行结果为:
aoligei test This is MainThreadmain 00
This is MainThreadmain 1
aoligei test 1
This is MainThreadmain 2
aoligei test 2
This is MainThreadmain 3
aoligei test 3
This is MainThreadmain 4
aoligei test 4
3)Thread的生命周期
1.创建对象时,代表Thread内部被初始化
2.调用start()方法后,thread会开始运行
3.thread代码正常运行结束或者遇到异常,线程会终止。
可以通过Thread的is_alive()方法查询线程是否还在运行。is_alive() 返回 True 的情况是 Thread 对象被正常初始化,start() 方法被调用,然后线程的代码还在正常运行。
import threading
import time
def test():
for i in range(5):
print(threading.current_thread().name+' test ',i,"*"*10)
time.sleep(0.5)
thread = threading.Thread(target=test,name='aoligei')
thread.start()
for i in range(5):
print(threading.current_thread().name+' main ', i)
print(thread.name+' is alive ', thread.is_alive())
time.sleep(1)
设置子线程的睡眠时间更短,可以让它早点结束
aoligei test MainThread main 00
aoligei is alive **********
True
aoligei test 1 **********
MainThread main 1
aoligei is alive True
aoligei test 2 **********
aoligei test 3 **********
MainThread main 2
aoligei is alive True
aoligei test 4 **********
MainThread main 3
aoligei is alive False
MainThread main 4
aoligei is alive False
4)join()方法提供阻塞手段
import threading
import time
def test():
for i in range(5):
print(threading.current_thread().name+' test ',i,"*"*10)
time.sleep(2)
thread = threading.Thread(target=test,name='aoligei')
thread.start()
thread.join()
for i in range(5):
print(threading.current_thread().name+' main ', i)
print(thread.name+' is alive ', thread.is_alive())
time.sleep(1)
调用一个 Thread 的 join() 方法,可以阻塞自身所在的线程。主线程创建了 aoligei 对象后,让其 start,然后通过调用 join() 方法,实现等待。程序运行结果如下:
aoligei test 0 **********
aoligei test 1 **********
aoligei test 2 **********
aoligei test 3 **********
aoligei test 4 **********
MainThread main 0
aoligei is alive False
MainThread main 1
aoligei is alive False
MainThread main 2
aoligei is alive False
MainThread main 3
aoligei is alive False
MainThread main 4
aoligei is alive False
默认情况下,join()会一直等待对应线程的结束,但可以通过参数赋值,等待规定的时间即可。
def join(self.timeout=None):
timeout是一个浮点参数,单位是秒。
5)守护线程
import threading
import time
def test():
for i in range(5):
print(threading.current_thread().name+' test ',i,"*"*10)
time.sleep(2)
thread = threading.Thread(target=test,name='aoligei')
thread.start()
for i in range(5):
print(threading.current_thread().name+' main ', i)
print(thread.name+' is alive ', thread.is_alive())
time.sleep(1)
输出为:
aoligei test MainThread main 00
**********aoligei is alive
True
MainThread main 1
aoligei is alive True
aoligei test 1 **********
MainThread main 2
aoligei is alive True
MainThread main 3
aoligei is alive True
aoligei test 2 **********
MainThread main 4
aoligei is alive True
aoligei test 3 **********
aoligei test 4 **********
MainThread结束运行后,aoligei仍然在运行,这是因为MainThread在等待其他线程的结束。
aoligei的daemon属性默认为False,这使得 MainThread 需要等待它的结束,自身才结束。
如果要达到守护线程(MainThread 结束,子线程也立马结束),怎么做呢? 其实很简单,只需要在子线程调用 start() 方法之前设置 daemon 就好了。 当然也可以在子线程的构造器中传递 daemon 的值为 True。
thread = threading.Thread(target=test,name='TestThread',daemon=True)
# thread.setDaemon(True)
修改之后运行结果为:
aoligei test MainThread main 00
aoligei is alive **********
True
MainThread main 1
aoligei is alive True
aoligei test 1 **********
MainThread main 2
aoligei is alive True
MainThread main 3
aoligei is alive True
aoligei test 2 **********
MainThread main 4
aoligei is alive True
6)线程数量
threading.enumerate():返回一个包含正在运行的线程的list。正在运行指线程启动后、结束前,不包括启动前和终止后的线程。
def enumerate():
“”"Return a list of all Thread objects currently alive.
The list includes daemonic threads, dummy thread objects created by current_thread(), and the main thread. It excludes terminated threads and threads that have not yet been started.
import threading
import time
def func1():
print("This is func1")
time.sleep(1)
def func2():
print("This is func2")
time.sleep(1)
for i in range(4):
t1=threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t2.start()
t1.start()
le=len(threading.enumerate())
print("当前线程数为",le)
运行结果为:
This is func2
This is func1当前线程数为
3
This is func2
This is func1当前线程数为
5
This is func2
This is func1当前线程数为
7
This is func2
This is func1当前线程数为
9
7)其他的方法
threading模块提供了一些比较实用的方法或者属性:
方法与属性 | 描述 |
---|---|
current_thread() | 返回当前线程 |
active_count() | 返回当前活跃的线程数,1个主线程+n个子线程 |
get_ident() | 返回当前线程 |
enumerate() | 返回当前活动 Thread 对象列表 |
main_thread() | 返回主 Thread 对象 |
settrace(func) | 为所有线程设置一个 trace 函数 |
setprofile(func) | 为所有线程设置一个 profile 函数 |
stack_size([size]) | 返回新创建线程栈大小;或为后续创建的线程设定栈大小为 size |
TIMEOUT_MAX | Lock.acquire(), RLock.acquire(), Condition.wait() 允许的最大超时时间 |
2.自定义类继承Thread
自定义一个Thread的子类,然后复写它的run()方法
import threading
import time
class TestThread(threading.Thread):
def __init__(self,name=None):
threading.Thread.__init__(self,name=name)
def run(self):
for i in range(5):
print(threading.current_thread().name+" test ",i)
time.sleep(1)
thread=TestThread(name='aoligei')
thread.start()
for i in range(5):
print(threading.current_thread().name+" main ",i)
time.sleep(1)
自定义了 TestThread 这个类,然后继承threading.Thread 只有在 run() 方法中处理逻辑,最终运行结果如下:
aoligei test MainThread main 00
aoligei test MainThread main 1
1
MainThread main 2
aoligei test 2
aoligei test 3
MainThread main 3
MainThread main 4
aoligei test 4
3.GIL
全局解释器锁(global interpreter lock),每个线程在执行时候都需要先获取GIL,保证同一时刻只有一个线程可以执行代码,即同一时刻只有一个线程使用CPU,也就是说多线程并不是真正意义上的同时执行。
Python的标准实现是CPython。
CPython执行Python代码分为2个步骤:首先,将文本源码解释编译为字节码,然后再用一个解释器去 解释运行字节码。字节码解释器是有状态的,为了维护该状态的一致性,因此使用了GIL(Global Interpreter Lock,全局解释器锁)。 GIL的存在,使得CPython在执行多线程代码的时候,同一时刻只有一个线程在运行,无法利用多CPU 提高运算效率。但是这个特点也带来了一个好处:CPython运行多线程的时候,内部对象缺省就是线程 安全的。这个特性,被非常多的Python库开发者所依赖,直到CPython的开发者想要去除GIL的时候, 发现已经有大量的代码库重度依赖这个GIL带来的内部对象缺省就是线程安全的特性,变成一个无法解 决的问题了。
虽然多线程在并行计算场景下无法带来好处,但是在阻塞式IO场景下,却仍然可以起到提高效率的作 用。这是因为阻塞式IO场景下,线程在执行IO操作时并不需要占用CPU时间,此时阻塞IO的线程可以被 挂起的同时继续执行IO操作,而让出CPU时间给其他线程执行非IO操作。这样一来,多线程并行IO操作 就可以起到提高运行效率的作用了。
综上,Python的标准实现CPython,由于GIL的存在,同一个时刻只能运行一个线程,无法充分利用多 CPU提升运算效率,因此Python的多线程适用于阻塞式IO的场景,不适用于并行计算的场景
4.多进程和多线程对比
引自菜鸟教程:参考链接
如果多线程的进程是CPU密集型的,那多线程并不能有多少效率上的提升,相反还可能会因为线程的频繁切换,导致效率下降,推荐使用多进程;
如果是IO密集型,多线程进程可以利用IO阻塞等待时的空闲时间执行其他线程,提升效率。所以我们根据实验对比不同场景的效率
多线程在IO密集型的操作下似乎也没有很大的优势(也许IO操作的任务再繁重一些就能体现出优势),在CPU密集型的操作下明显地比单线程线性执行性能更差,但是对于网络请求这种忙等阻塞线程的操作,多线程的优势便非常显著了
多进程无论是在CPU密集型还是IO密集型以及网络请求密集型(经常发生线程阻塞的操作)中,都能体现出性能的优势。不过在类似网络请求密集型的操作上,与多线程相差无几,但却更占用CPU等资源,所以对于这种情况下,我们可以选择多线程来执行