线程

最新推荐文章于 2024-02-12 13:02:04 发布

like_study_cat

最新推荐文章于 2024-02-12 13:02:04 发布

阅读量69

点赞数

分类专栏： python

本文链接：https://blog.csdn.net/like_study_cat/article/details/103629234

版权

python 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

Python多线程编程(一）：threading 模块 Thread 类的用法详解

我们进行程序开发的时候，肯定避免不了要处理并发的情况。

一般并发的手段有采用多进程和多线程。

但线程比进程更轻量化，系统开销一般也更低，所以大家更倾向于用多线程的方式处理并发的情况。

Python 提供多线程编程的方式。

本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模块。

所以，我们要在代码中引用它。

import threading

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)

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')

那么，运行结果会变成这个样子。

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):

timeout 是一个浮点参数，单位是秒。

如果我们更改上面的代码。

thread.join(1.0)

它的结果会是这样。

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)

更改前面代码示例，运行结果如下

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 多线程编码技术就大致介绍完毕，大家可以进行实际代码编写了。

但是，多线程编程的难点在于多个线程之间共享数据的同步，这是非常容易出错的地方，我将分别编写相应的博文去介绍一些高级的技术点。

转自：https://blog.csdn.net/briblue/article/details/85101144

like_study_cat

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程

Python多线程编程(一）：threading 模块 Thread 类的用法详解我们进行程序开发的时候，肯定避免不了要处理并发的情况。一般并发的手段有采用多进程和多线程。但线程比进程更轻量化，系统开销一般也更低，所以大家更倾向于用多线程的方式处理并发的情况。Python 提供多线程编程的方式。本文基于 Python3 讲解,Python 实现多线程编程需要借助于 threading 模...
复制链接

扫一扫