首页 > 上网技巧 > Python多线程编程 threading 模块 Thread 类的...

Python多线程编程 threading 模块 Thread 类的用法详解

时间:2021-02-02 13:47 作者:QQ地带 我要评论

我们进行程序开发的时候,肯定避免不了要处理并发的情况。
 
一般并发的手段有采用多进程和多线程。
 
但线程比进程更轻量化,系统开销一般也更低,所以大家更倾向于用多线程的方式处理并发的情况。
 
Python 提供多线程编程的方式。
 
本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模块。
 
所以,我们要在代码中引用它。
 
import threading
1
threading 模块中最核心的内容是 Thread 这个类。
 
我们要创建 Thread 对象,然后让它们运行,每个 Thread 对象代表一个线程,在每个线程中我们可以让程序处理不同的任务,这就是多线程编程。
 
值得注意的是,程序运行时默认就是在主线程上
 
创建 Thread 对象有 2 种手段。
 
直接创建 Thread ,将一个 callable 对象从类的构造器传递进去,这个 callable 就是回调函数,用来处理任务。
编写一个自定义类继承 Thread,然后复写 run() 方法,在 run() 方法中编写任务处理代码,然后创建这个 Thread 的子类。
1. 直接创建 Thread 对象。
class threading.Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
1
Thread 的构造方法中,最重要的参数是 target,所以我们需要将一个 callable 对象赋值给它,线程才能正常运行。
 
如果要让一个 Thread 对象启动,调用它的 start() 方法就好了。
 
下面是代码示例。
 
import threading
import time
 
def test():
 
    for i in range(5):
        print('test ',i)
        time.sleep(1)
 
 
thread = threading.Thread(target=test)
thread.start()
 
for i in range(5):
    print('main ', i)
    time.sleep(1)
 
上面代码很简单,在主线程上打印 5 次,在一个子线程上打印 5 次。
 
运行结果如下:
 
test  0
main  0
main  1
test  1
main  2
test  2
main  3
test  3
main  4
test  4
 
上面的 callable 没有参数,如果需要传递参数的话,args 是固定参数,kwargs 是可变参数。
 
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(threading.current_thread().name+' main ', i)
    time.sleep(1)
 
通过 thread.current_thread() 方法可以返回线程本身,然后就可以访问它的 name 属性。
 
上面代码运行结果如下:
 
Thread-1 test  0
MainThread main  0
Thread-1 test  1
MainThread main  1
Thread-1 test  2
MainThread main  2
Thread-1 test  3
MainThread main  3
Thread-1 test  4
MainThread main  4
 
如果我们在 Thread 对象创建时,构造方法里面赋值。
 
thread = threading.Thread(target=test,name='TestThread')
1
那么,运行结果会变成这个样子。
 
TestThread test  0
MainThread main  0
MainThread main  1
TestThread test  1
MainThread main  2
TestThread test  2
MainThread main  3
TestThread test  3
MainThread main  4
TestThread test  4
 
Thread 的生命周期
创建对象时,代表 Thread 内部被初始化。
调用 start() 方法后,thread 会开始运行。
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)
        time.sleep(0.5)
 
 
thread = threading.Thread(target=test,name='TestThread')
# thread = threading.Thread(target=test)
thread.start()
 
for i in range(5):
    print(threading.current_thread().name+' main ', i)
    print(thread.name+' is alive ', thread.isAlive())
    time.sleep(1)
 
在上面的代码中,我让 TestThread 比 MainThread 早一点结束,代码运行结果如下。
 
TestThread test  0
MainThread main  0
TestThread is alive  True
TestThread test  1
MainThread main  1
TestThread is alive  True
TestThread test  2
TestThread test  3
MainThread main  2
TestThread is alive  True
TestThread test  4
MainThread main  3
TestThread is alive  False
MainThread main  4
TestThread is alive  False
 
我们可以看到,主线程通过调用 TestThread 的 isAlive() 方法,准确查询到了它的存货状态。
 
join() 提供线程阻塞手段。
上面代码两个线程是同时运行的,但如果让一个先运行,一个后运行,怎么做呢?
 
调用一个 Thread 的 join() 方法,可以阻塞自身所在的线程。
 
import threading
import time
 
def test():
 
    for i in range(5):
        print(threading.current_thread().name+' test ',i)
        time.sleep(0.5)
 
 
thread = threading.Thread(target=test,name='TestThread')
thread.start()
thread.join()
 
for i in range(5):
    print(threading.current_thread().name+' main ', i)
    print(thread.name+' is alive ', thread.isAlive())
    time.sleep(1)
 
主线程创建了 TestThread 对象后,让其 start,然后通过调用 join() 方法,实现等待。程序运行结果如下:
 
TestThread test  0
TestThread test  1
TestThread test  2
TestThread test  3
TestThread test  4
MainThread main  0
TestThread is alive  False
MainThread main  1
TestThread is alive  False
MainThread main  2
TestThread is alive  False
MainThread main  3
TestThread is alive  False
MainThread main  4
TestThread is alive  False
 
默认的情况是,join() 会一直等待对应线程的结束,但可以通过参数赋值,等待规定的时间就好了。
 
def join(self, timeout=None):
1
timeout 是一个浮点参数,单位是秒。
 
如果我们更改上面的代码。
 
thread.join(1.0)
1
它的结果会是这样。
 
TestThread test  0
TestThread test  1
MainThread main  0
TestThread is alive  True
TestThread test  2
TestThread test  3
MainThread main  1
TestThread is alive  True
TestThread test  4
MainThread main  2
TestThread is alive  False
MainThread main  3
TestThread is alive  False
MainThread main  4
TestThread is alive  False
 
主线程只等待了 1 秒钟。
 
Thread 中的 daemon 属性
有同学可能会注意到,Thread 的构造方法中有一个 daemon 参数。默认是 None。
 
那么,daemon 起什么作用呢?
 
我们先看一段示例代码。
 
import threading
import time
 
def test():
 
    for i in range(5):
        print(threading.current_thread().name+' test ',i)
        time.sleep(2)
 
 
thread = threading.Thread(target=test,name='TestThread')
# thread = threading.Thread(target=test,name='TestThread',daemon=True)
thread.start()
 
 
for i in range(5):
    print(threading.current_thread().name+' main ', i)
    print(thread.name+' is alive ', thread.isAlive())
    time.sleep(1)
 
我们让主线程执行代码的时长比 TestThread 要短。
 
程序运行结果如下。
 
TestThread test  0
MainThread main  0
TestThread is alive  True
MainThread main  1
TestThread is alive  True
TestThread test  1
MainThread main  2
TestThread is alive  True
MainThread main  3
TestThread is alive  True
TestThread test  2
MainThread main  4
TestThread is alive  True
TestThread test  3
TestThread test  4
 
MainThread 没有代码运行的时候,TestThread 还在运行。
 
这是因为 MainThread 在等待其他线程的结束。
 
TestThread 中 daemon 属性默认是 False,这使得 MainThread 需要等待它的结束,自身才结束。
 
如果要达到,MainThread 结束,子线程也立马结束,怎么做呢?
 
其实很简单,只需要在子线程调用 start() 方法之前设置 daemon 就好了。
 
当然也可以在子线程的构造器中传递 daemon 的值为 True。
 
thread = threading.Thread(target=test,name='TestThread',daemon=True)
# thread.setDaemon(True)
1
2
更改前面代码示例,运行结果如下
 
TestThread test  0
MainThread main  0
TestThread is alive  True
MainThread main  1
TestThread is alive  True
TestThread test  1
MainThread main  2
TestThread is alive  True
MainThread main  3
TestThread is alive  True
TestThread test  2
MainThread main  4
TestThread is alive  True
 
可以看到 MainThread 结束了 TestThread 也结束了。
 
2.自定义类继承 Thread
前面讲过,直接初始化一个 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='TestThread')
thread.start()
 
 
for i in range(5):
    print(threading.current_thread().name+' main ', i)
    print(thread.name+' is alive ', thread.isAlive())
    time.sleep(1)
 
上面的代码,我们自定义了 TestThread 这个类,然后继承了 threading.Thread。
 
只有在 run() 方法中处理逻辑。最终代码运行结果如下:
 
TestThread test  0
MainThread main  0
TestThread is alive  True
TestThread test  1
MainThread main  1
TestThread is alive  True
TestThread test  2
MainThread main  2
TestThread is alive  True
MainThread main  3
TestThread is alive  True
TestThread test  3
MainThread main  4
TestThread test  4
TestThread is alive  True
 
这与之前的效果并无差异,但我还是推荐用这种方法,毕竟面向对象编程嘛。
 
自此,Python 多线程编码技术就大致介绍完毕,大家可以进行实际代码编写了。
 
但是,多线程编程的难点在于多个线程之间共享数据的同步,这是非常容易出错的地方,我将分别编写相应的博文去介绍一些高级的技术点。

标签: Python
顶一下
(0)
0%
踩一下
(0)
0%

Google提供的广告