Python线程中start，run，join方法及守护线程模式的作用

正常人谁写代码啊

已于 2024-05-23 10:44:09 修改

阅读量664

点赞数 32

分类专栏： Python高级笔记📖 文章标签： python 开发语言爬虫 django 数据结构

于 2024-05-16 14:36:10 首次发布

本文链接：https://blog.csdn.net/qq_44972955/article/details/138854720

版权

Python高级笔记📖 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

一、术语定义

并发：是指在时间上交替进行多个任务，即任务之间可能快速切换，给人一种同时进行的感觉，但每个时刻实际上只有一个任务在运行。并发可以在单核CPU上实现，通过操作系统的任务调度来实现任务的交替执行。并发也叫多任务处理。

并行：是指同时执行多个任务，即在同一时间点，有多个任务在真正地进行计算。并行通常依赖于多核处理器或多处理器系统。

执行单元：并发执行代码的对象的统称

线程：单个进程中的执⾏单元。⼀个进程启动后，只使⽤⼀个线程，即主线程。通过调⽤操作系统 API ，进程可以创建更多线程，执⾏并发操作。⼀个进程内的线程共享相同的内存空间（存储活动的 Python 对象）。因此，线程之间可以轻松地共享数据，但是如果多个线程同时更新同⼀个对象，则可能导致数据损坏。与进程⼀样，线程在操作系统调度程序的监督下也可以实现抢占式多任务处理。对于同⼀份作业，线程消耗的资源⽐进程少。

二、内容

1.start()方法和run()方法的区别

Thread类提供了start()和run()两个方法，他们在启动和执行线程时扮演不同角色。

`start()`方法：

功能：start()方法用于启动一个线程，调用此方法会通知Python解释器为该线程分配资源，并调用线程的run()方法。
线程化：start()方法会在后台创建一个新线程来运行目标函数。
多次调用：一个线程对象的start()方法只能调用一次。如果尝试多从调用，python会抛出`RuntimeError`

`run()`方法：

功能：run()方法包含线程的实际执行代码。在没有显示调用start()方法的情况下，可以直接调用run()方法，但这种方式不会创建新线程，而是同步执行run()方法中的代码。
直接调用：如果直接调用run()方法，它会在当前线程（通常是主线程）中同步执行，就像调用普通函数一样。

具体区别：

启动新线程:

start(): 启动一个新线程并在新线程中执行run()方法中的代码。
run(): 在当前线程中同步执行run()方法中的代码，不会启动新线程

并发执行：

start(): 实现并发执行，可以在多个线程中同时运行不同的代码。
run(): 无法实现并发执行，代码在当前线程中顺序执行。

我们先使用start()，示例如下：

import time
import threading


def target_fun():
    for i in range(5):
        time.sleep(1)
        print(f"{threading.current_thread()} is running: {i}")


if __name__ == '__main__':
    t1 = threading.Thread(target=target_fun,name='T1')
    t2 = threading.Thread(target=target_fun,name='T2')
    t1.start()
    t2.start()
    t1.join()
    t2.join()
# 输出结果
# <Thread(T1, started 9956)> is running: 0
# <Thread(T2, started 20164)> is running: 0
# <Thread(T1, started 9956)> is running: 1
# <Thread(T2, started 20164)> is running: 1
# <Thread(T2, started 20164)> is running: 2
# <Thread(T1, started 9956)> is running: 2
# <Thread(T2, started 20164)> is running: 3
# <Thread(T1, started 9956)> is running: 3
# <Thread(T2, started 20164)> is running: 4
# <Thread(T1, started 9956)> is running: 4

下面使用join()，示例如下：

import time
import threading


def target_fun():
    for i in range(5):
        time.sleep(1)
        print(f"{threading.current_thread()} is running: {i}")


if __name__ == '__main__':
    t1 = threading.Thread(target=target_fun,name='T1')
    t2 = threading.Thread(target=target_fun,name='T2')
    t1.run()
    t2.run()
# 输出结果
# <_MainThread(MainThread, started 3160)> is running: 0
# <_MainThread(MainThread, started 3160)> is running: 1
# <_MainThread(MainThread, started 3160)> is running: 2
# <_MainThread(MainThread, started 3160)> is running: 3
# <_MainThread(MainThread, started 3160)> is running: 4
# <_MainThread(MainThread, started 3160)> is running: 0
# <_MainThread(MainThread, started 3160)> is running: 1
# <_MainThread(MainThread, started 3160)> is running: 2
# <_MainThread(MainThread, started 3160)> is running: 3
# <_MainThread(MainThread, started 3160)> is running: 4

可以看出，使用run()方法时，并没有创建新的线程，而是在主线程里面同步执行。那为什么没有join()呢？那当然啊，因为join()方法要在start()方法之后使用，run()方法都没有创建线程肯定无法调用statr()啊，当然也就无法使用join()方法了。不信你可以试试！

2.join()方法的作用

join()方法用于阻塞调用它的线程，直到被调用的线程完成其执行。join()方法确保一个线程在继续执行后续代码之前，等待其他线程完成。这在多线程编程中非常有用，因为它可以确保线程按预期的顺序执行，避免数据竞争和其他并发问题。

作用：

同步线程：确保主线程等待子线程完成后再继续执行后续代码。
协调线程执行顺序：控制线程执行的顺序，防止线程间的竞争条件。
避免资源冲突：确保在访问共享资源之前，所有相关线程都已经完成操作

示例如下：

我们先看看没有join()的行为：

import threading
import time
def other():
    print("Other behaviors")
    print("All threads have finished")
def worker(name, delay):
    print(f"Thread {name} starting")
    time.sleep(delay)
    print(f"Thread {name} finished")

# 创建线程
thread1 = threading.Thread(target=worker, args=("Worker-1", 2))
thread2 = threading.Thread(target=worker, args=("Worker-2", 3))
# 启动线程
thread1.start()
thread2.start()
other()
# 输出
# Thread Worker-1 starting
# Thread Worker-2 starting
# Other behaviors
# All threads have finished
# Thread Worker-1 finished
# Thread Worker-2 finished

可以看出没有join()方法阻塞，线程1和线程2开始以后没有等待这两个线程执行完就调用other()函数，执行other()函数里面的内容。下面看看有join()方法的行为

import threading
import time
def other():
    print("Other behaviors")
    print("All threads have finished")
def worker(name, delay):
    print(f"Thread {name} starting")
    time.sleep(delay)
    print(f"Thread {name} finished")

# 创建线程
thread1 = threading.Thread(target=worker, args=("Worker-1", 2))
thread2 = threading.Thread(target=worker, args=("Worker-2", 3))
# 启动线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
other()
# 输出
# Thread Worker-1 starting
# Thread Worker-2 starting
# Thread Worker-1 finished
# Thread Worker-2 finished
# Other behaviors
# All threads have finished

很明显，两个线程执行完才调用的other()函数

3.守护线程（Daemon Thread）

在Python中，守护线程（Daemon Thread）是一种特殊的线程，它在主线程结束时会自动终止。与非守护线程不同，守护线程不会阻止程序的退出。这种线程通常用于后台任务，如日志记录、定时任务等。

非守护线程：

import threading
import time

def background_task():
    while True:
        print("后台任务运行中...")
        time.sleep(2)

# 创建线程
t = threading.Thread(target=background_task)

# 启动线程
t.start()

# 主线程运行一段时间后退出
time.sleep(5)
print("主线程结束")

# 结果
后台任务运行中...
后台任务运行中...
后台任务运行中...
主线程结束
后台任务运行中...
后台任务运行中...
后台任务运行中...

非守护模式下，主线程结束后，子线程依然还在运行。下面看看守护线程模式：

import threading
import time

def background_task():
    while True:
        print("后台任务运行中...")
        time.sleep(2)

# 创建线程
t = threading.Thread(target=background_task,daemon=True)

# 启动线程
t.start()

# 主线程运行一段时间后退出
time.sleep(5)
print("主线程结束")

#输出
后台任务运行中...
后台任务运行中...
后台任务运行中...
主线程结束

守护模式下，主线程结束后，子线程也终止了。

守护线程的特点

生命周期: 守护线程的生命周期依赖于主线程。当所有非守护线程结束时，程序将退出，即使有守护线程仍在运行。
应用场景: 常用于需要在后台运行的任务，如日志记录、监控、定时任务等，不需要等待其完成。
终止方式: 主线程结束时，守护线程会被强制终止，而不会执行任何清理操作。因此，守护线程中不应包含重要的、需要保证完成的任务。

正常人谁写代码啊

关注

32
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Python线程中start，run，join方法及守护线程模式的作用

单个进程中的执⾏单元。⼀个进程启动后，只使⽤⼀个线程，即主线程。通过调⽤操作系统 API ，进程可以创建更多线程，执⾏并发操作。⼀个进程内的线程共享相同的内存空间（存储活动的 Python 对象）。因此，线程之间可以轻松地共享数据，但是如果多个线程同时更新同⼀个对象，则可能导致数据损坏。与进程⼀样，线程在操作系统调度程序的监督下也可以实现抢占式多任务处理。对于同⼀份作业，线程消耗的资源⽐进程少。
复制链接

扫一扫