【Python】- Thread多线程的使用（全）

Python Thread多线程使用全解析
原创 已于 2025-02-15 01:22:54 修改 · 1.5k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

于 2025-02-14 15:36:55 首次发布

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

提示：提到多线程必须要先明白关键词的定义：

例如：进程和线程的概念。

  1. 进程是指一个程序，比如在电脑里面运行的QQ，浏览器就是一个进程。每个进程之间相互隔离，占用不同的资源，一个进程至少包含一个线程。
  2. 线程就是一个进程里面的一部分，一个进程可以拥有多个线程，其中包含一个主线程，多个线程并发实现效率的提高。

提示：以下是本篇文章正文内容，下面案例可供参考

一、threading是什么？

示例：Thread是python已经存在的标准库，该模块提供了强大的多线程编程支持。通过Thread类可以创建和管理线程，使用Lock、Queue等工具可以解决线程同步和通信问题。对于I/O密集型任务，多线程可以有效提高效率。

二、使用步骤

1.引入模块

代码如下（示例）：

import threading

2.创建多线程

代码如下（示例）：

import threading
import time


def target_1():
    for i in range(5):
        print("线程函数 1")
        time.sleep(1)


def target_2():
    for i in range(5):
        print("线程函数 2")
        time.sleep(1)


def th1():
    th = threading.Thread(target=target_1)  # 新建一个线程
    th.start()
    return th


def th2():
    th = threading.Thread(target=target_2)
    th.start()
    return th


def _main():
    print("主线程开始")
    threading_1 = th1()
    threading_2 = th2()
    print("主线程结束")


if __name__ == '__main__':
    start_time = time.perf_counter()
    _main()
    end_time = time.perf_counter()
    total_time = end_time - start_time
    # print(f"耗时： {total_time}")

以上代码实现创建两个线程，并且执行。

3.多线程目标函数传递参数

假如遇到目标函数需要传递参数，稍加修改，示例代码如下

import threading
import time


def target_1(name):
    for i in range(5):
        print(name + " 线程函数 1")
        time.sleep(1)


def target_2(name):
    for i in range(5):
        print(name + " 线程函数 2")
        time.sleep(1)


def th1():
    th = threading.Thread(target=target_1, args=("Tom",))  # 新建一个线程
    th.start()
    return th


def th2():
    th = threading.Thread(target=target_2, args=("Jerry",))
    th.start()
    return th


def _main():
    print("主线程开始")
    threading_1 = th1()
    threading_2 = th2()
    print("主线程结束")


if __name__ == '__main__':
    start_time = time.perf_counter()
    _main()
    end_time = time.perf_counter()
    total_time = end_time - start_time
    # print(f"耗时： {total_time}")

代码输出如下：

在这里插入图片描述

4. 等待线程结束 join()

以上代码的输出来看，似乎遇到一个问题，那就是主线程已经结束了，创建执行的子线程还在运行，那就不能等所有线程都执行完了，程序再结束吗？这就需要用到 .join

修改代码如下：

import threading
import time


def target_1(name):
    for i in range(5):
        print(name + " 线程函数 1")
        time.sleep(1)


def target_2(name):
    for i in range(5):
        print(name + " 线程函数 2")
        time.sleep(1)


def th1():
    th = threading.Thread(target=target_1, args=("Tom",))  # 新建一个线程
    th.start()
    return th


def th2():
    th = threading.Thread(target=target_2, args=("Jerry",))
    th.start()
    return th


def _main():
    print("主线程开始")
    threading_1 = th1()
    threading_2 = th2()
    threading_1.join()
    threading_2.join()
    print("主线程结束")


if __name__ == '__main__':
    start_time = time.perf_counter()
    _main()
    end_time = time.perf_counter()
    total_time = end_time - start_time
    # print(f"耗时： {total_time}")

我们在主线程结束之间，加上线程对象调用 .join() 方法，程序就会在线程执行结束后才会执行下一句，输出如下：

在这里插入图片描述

5. 线程同步 Lock()

如果同时调用了多个线程资源，并且同时start(), 就会造成竞争关系，这时候就需要做线程同步使得线程在某个步骤可以依次进行。

示例代码输出看起来是没问题的，但是其实两个线程之间已经构成了竞争，在输出打印的时候，他们在同一个时间输出，导致输出的格式看起来不是依次进行的。我们对打印操作做加锁和释放的操作，这样两个线程就不会在同一时刻在打印的时候有竞争关系，示例代码如下：

import threading
import time

lock = threading.Lock()


def target_1(name):
    for i in range(5):
        lock.acquire()  # 加锁
        print(name + " 线程函数 1")
        lock.release()  # 释放锁
        time.sleep(1)


def target_2(name):
    for i in range(5):
        lock.acquire()  # 加锁
        print(name + " 线程函数 2")
        lock.release()  # 释放锁
        time.sleep(1)


def th1():
    th = threading.Thread(target=target_1, args=("Tom",))  # 新建一个线程
    th.start()
    return th


def th2():
    th = threading.Thread(target=target_2, args=("Jerry",))
    th.start()
    return th


def _main():
    print("主线程开始")
    threading_1 = th1()
    threading_2 = th2()
    threading_1.join()
    threading_2.join()
    print("主线程结束")


if __name__ == '__main__':
    start_time = time.perf_counter()
    _main()
    end_time = time.perf_counter()
    total_time = end_time - start_time
    # print(f"耗时： {total_time}")

输入如下：

在这里插入图片描述

注意： 如果两个线程同时调用进程里面的同一个资源，比如同一个变量，在线程里面处理这个资源时候也要加锁，避免多个线程在处理这个资源时候造成竞争，也就是说这个变量并没有被执行更新就同时被线程调用。

6. 线程之间通信，队列queue的使用

前面我们提到了线程对象的创建，开启，等待执行结束，但是没有提到怎么结束一个线程，那有结束一个线程的方法吗？答案是没有，线程在执行完成后才会自己结束，但是我们可以用传递参数的方式让线程自己退出。

示例代码如下：

import threading
import time

stop_target_1 = False


def target_1():
    global stop_target_1
    while True:
        if stop_target_1:
            break
        time.sleep(1)
        print("正在运行子线程")


def _main():
    global stop_target_1
    th = threading.Thread(target=target_1)
    th.start()  # 开启线程
    print("运行主线程")
    time.sleep(5)
    stop_target_1 = True  # 结束线程
    th.join()
    print("结束主线程")


if __name__ == '__main__':
    _main()

输出结果如下：

在这里插入图片描述

我们还可以通过队列queue，控制线程的启动和结束，队列主要包含get和put两个方法，put是往队列里放入参数，get是在队列里取参数。

注意：假如队列里没有参数，get() 处于阻塞状态。

通过队列参数的传递控制线程的启动和结束，示例代码如下：

import threading
import time
import queue

q = queue.Queue()


def target_1(q):
    while True:
        item = q.get()
        if item is None:
            break
        time.sleep(1)
        print("正在运行子线程")
        q.task_done()


def _main():
    th = threading.Thread(target=target_1, args=(q,))
    th.start()  # 开启线程
    print("运行主线程")
    for i in range(5):
        time.sleep(1)
        q.put(1)
    q.put(None)
    th.join()
    print("结束主线程")


if __name__ == '__main__':
    _main()

同理，两个子线程之间也可以通过队列传递参数

import threading
import queue
import time


def producer(q):
    for i in range(5):
        print(f"Producing {i}")
        q.put(i)
        time.sleep(1)


def consumer(q):
    while True:
        item = q.get()
        if item is None:  # 结束信号
            break
        print(f"Consuming {item}")
        time.sleep(2)
        q.task_done()


# 创建队列
q = queue.Queue()

# 创建生产者线程
producer_thread = threading.Thread(target=producer, args=(q,))

# 创建消费者线程
consumer_thread = threading.Thread(target=consumer, args=(q,))

# 启动线程
producer_thread.start()
consumer_thread.start()

# 等待生产者完成
producer_thread.join()

# 发送结束信号
q.put(None)

# 等待消费者完成
consumer_thread.join()

7. 守护线程 （Daemon Thread）

守护线程就一个特点，即当所有非守护线程结束时，守护线程会自动终止。从上面示例可以看出主线程退出后，子线程只有运行结束后整个程序才会退出，但是守护线程当主线程执行完成后会被强制结束。

代码如下：

import threading
import time


def background_task():
    while True:
        time.sleep(0.5)
        print("子线程正在执行")


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

# 设置为守护线程
daemon_thread.daemon = True

# 启动线程
daemon_thread.start()

# 主线程继续执行
print("主线程开始运行")
time.sleep(2)  # 模拟主线程任务
print("主线程结束运行")

# 程序退出时，守护线程会自动终止

执行结果如下：

在这里插入图片描述

注意：当然，如果不想守护进程结束，同样可以通过 .jojn() 方法，等待线程结束程序才退出。

8. 线程池 concurrent.futures 模块

在 Python 中，concurrent.futures 模块提供了 ThreadPoolExecutor 类，用于创建和管理线程池。线程池可以帮助你并发地执行多个任务，而不需要手动创建和管理线程。

加入我们有多个任务（5个）需要多线程运行，有了线程池，只要我们定义好多少个线程，然后把任务交给它就行，线程池会自动调度线程按最大线程数执行完毕，示例代码如下：

import concurrent.futures
import time

# 定义一个简单的任务函数
def task(n):
    print(f"Task {n} started")
    time.sleep(2)  # 模拟耗时操作
    print(f"Task {n} finished")
    return f"Task {n} result"

# 使用 ThreadPoolExecutor 创建线程池
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    # 提交任务到线程池
    futures = [executor.submit(task, i) for i in range(5)]
    
    # 获取任务的结果
    for future in concurrent.futures.as_completed(futures):
        try:
            result = future.result()
            print(f"Result: {result}")
        except Exception as e:
            print(f"Exception: {e}")

代码中用with方法创建线程池，循环5次把任务提交给执行器，这时候线程就会自动启动了，同时也可以通过返回的迭代器对象futures获取线程执行结果。

最大线程等于CPU核心数乘以5，在python中获取CPU核心数方法如下：

在这里插入图片描述

总结

例如：以上就是今天要讲的内容，本文主要介绍了Thread在Python中的主要用法。

大执
关注
【Python】多线程的使用以及注意事项
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
07-17 1887
Python中的多线程允许你并行地执行多个任务，从而充分利用多核CPU的优势。然而，由于Python的全局解释器锁（GIL）的存在，标准的Python线程在CPU密集型任务上可能并不会带来真正的并行执行优势。但在IO密集型任务（如网络通信、文件读写等）上，多线程仍然可以提高程序的整体性能。
Python 多线程
LadonDU的博客
08-02 848
Python多线程的使用以及相关模块介绍
Python多线程技术详解：从基础到实践
最新发布
软件开发领域最优质的博客
09-17 1028
本文深入探讨Python多线程编程技术，从基础概念到实际应用。首先介绍线程与进程的区别及多线程优势，重点讲解threading模块的使用方法，包括线程创建、参数传递和同步机制（Lock/RLock）。针对Python特有的GIL限制，分析其对性能的影响及解决方案。通过文件下载示例展示多线程的I/O密集型应用场景，最后总结多线程的优缺点及适用情况。文章为开发者提供了Python多线程技术的全面指导，帮助在实际项目中合理运用这一编程工具。
python学习笔记——Thread常用方法
xiaodanpeng的专栏
12-09 797
Thread对象中的一些方法：    以前说过多线程，用到threading模块中的Thread对象，其中的start和run方法比较熟悉了，start（）是重载了Thread对象中的run方法，其实作用还是，当执行这个start方法的时候，将运行run方法。    今天看看其他几个重要的方法：     1join方法，如果一个线程或者一个函数在执行过程中要调用另外一个线程，并且待到其完成
python使用多线程
weixin_30835933的博客
09-18 186
threading 模块支持守护线程， 其工作方式是：守护线程一般是一个等待客户端请求服务的服务器。 如果把一个线程设置为守护线程，进程退出时不需要等待这个线程执行完成。 如果主线程准备退出时，不需要等待某些子线程完成，就可以为这些子线程设置守护线程标记。 需要在启动线程之前执行如下赋值语句： thread.daemon = True，检查线程的守护状态也只需要检查这个值即可。 整个 Py...
python多线程：Thread类的用法
热门推荐
liulanba的博客
03-06 1万+
自定义一个Thread的子类，然后复写它的run()方法3.GIL全局解释器锁（global interpreter lock），每个线程在执行时候都需要先获取GIL，保证同一时刻只有一个线程可以执行代码，即同一时刻只有一个线程使用CPU，也就是说多线程并不是真正意义上的同时执行。Python的标准实现是CPython。CPython执行Python代码分为2个步骤：首先，将文本源码解释编译为字节码，然后再用一个解释器去 解释运行字节码。
Python-python多线程函数库vthread简而强大
08-12
vthread库是针对Python的一个增强型多线程库，它的主要目标是简化多线程和线程池的使用，提高开发效率。与Python标准库中的`threading`相比，vthread库强调的是最小化代码改动就能实现多线程和线程池功能，这使得...
Python—-多线程—-Thread
12-22
线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存（数据共享，共享全局变量),从而极大地提高了程序的运行效率。 线程的运行是没有...
PYthon-multithreading-Test.rar_python_python 多线程_python多线程_多线程
09-19
本压缩包“PYthon-multithreading-Test.rar”包含了有关Python多线程测试的源码，旨在帮助用户深入理解和实践Python的线程操作。 Python中的多线程是通过`threading`模块实现的，这个模块提供了基本的线程和同步...
python-多线程教程.pdf
02-05
### Python多线程教程知识点详解 #### 一、线程与多线程概念 - **线程**：线程是程序执行流的最小单位。一个标准的程序至少包含一个线程，即主运行线程（MainThread）。在多线程编程中，我们可以创建额外的线程来...
Python多线程的使用
KK_2018的技术博客_程序员不止是程序员
01-24 1547
1.线程之间执行是无序的，cpu调度哪个线程就执行哪个线程； 2.主线程等待所有子线程结束后再结束，设置守护线程可以实现当主线程结束时子线程立马结束； 3.设置守护线程：1.threading.Thread(daemon=True),2.线程对象.setDaemon(True)； 4.线程之间共享全局变量，存在资源竞争问题。 ''' 线程之间执行是无序的，cpu调度哪个线程就执行哪个线程 主线程会等待所有子线程结束之后再结束，设置守护线程可以实现当主线程结束时子线程立马结束 设置守护线程：1.threa
Python 多线程的使用
fw19940314的博客
03-29 5111
        多线程，python中创建多线程模块是Threading模块，Python中Thread是比较底层的模块，Threading是对Thread模块的封装。         首先使用threading模块来创建线程；import threading def say(): print("-------子线程-------") if __name__ == "__main__...
【Python】thread使用
hanhan的博客
02-18 752
1、Condition条件变量使用 2、event通信 3、Semaphore信号量使用 4、setDaemon设置守护线程 5、threadPool_map使用 6、threadPool使用 7、threadingTimer
python的多线程使用
Kevin_Xie86的博客
08-22 3089
​ Python3中官方才正式提供线程池，而且线程不是开的越多越好，开的多了可能会导致系统的性能更低。**结论：**主线程结束后，无论子线程1，2是否运行完成，都结束线程，不再继续向下运行。当不开启守护进程时，主程序将一直等待子程序全部运行完成才结束。**注意：**如果要设置为守护线程，一定要在开启线程之前(**结论：**主线程等待50个子线程全部执行完成才结束。)，主线程执行完自己的任务后，就退出了，此时。，设置子线程为守护线程，实现主程序结束，)，将该线程设置为守护线程。​ Python多线程。
python中多线程的使用
cheng_ji的专栏
01-01 1359
Python 提供了强大的threading模块来支持多线程编程，通过线程池、锁、事件等机制，我们可以高效地处理并发任务。虽然由于 GIL 的存在，Python 的多线程并不能在 CPU 密集型任务中显著提升性能，但在 I/O 密集型任务中，多线程的使用可以极大提高效率。
Python多线程的用法
leetteel
09-17 806
每个线程都有他自己的一组CPU寄存器，称为线程的上下文，该上下文反映了线程上次运行该线程的CPU寄存器的状态。_thread提供了低级别的、原始的线程以及一个简单的锁，它相比于threading模块的功能还是比较有限的。这阻塞调用线程直至线程的join()方法被调用中止-正常退出或者抛出未处理的异常-或者是可选的超时发生。● threading.activeCount()：返回正在运行的线程数量，与len(threading.enumerate())有相同的结果。● run()：用以表示线程活动的方法。
python多线程
hutaotaotao的博客
05-27 2237
python多线程知识大全
Python多线程使用详解
Rocky006的博客
07-11 8352
多线程是一种并发编程的技术，通过同时执行多个线程来提高程序的性能和效率。在Python中，我们可以使用内置的threading模块来实现多线程编程。
gopython 多线程问题_python--threading多线程
06-07
好的，关于 Python 中的多线程问题，可以使用 `threading` 模块来实现。`threading` 模块提供了 `Thread` 类，可以用于创建线程。可以通过以下步骤来使用 `threading` 模块实现多线程： 1. 导入 `threading` 模块。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值