Python Threading 线程模块用法

article/2025/10/6 19:08:56

一、什么是 Threading 

Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。python当前版本的多线程库没有实现优先级、线程组，线程也不能被停止、暂停、恢复、中断。

1.1、线程池图解

二、创建线程

导入模块threading，通过threading.Thread()创建线程。其中target接收的是要执行的函数名字，args接收传入函数的参数，以元组（）的形式表示。

import threadingdef foo(n):print("foo%s"%n)
t1 = threading.Thread(target=foo,args=(1,))　　#创建线程对象

三、启动线程

通过线程对象t1.start()或t2.start()启动线程。

t1 = threading.Thread(target=sayhi, args=(1,))  # 生成一个线程实例
t2 = threading.Thread(target=sayhi, args=(2,))  # 生成另一个线程实例t1.start()  # 启动线程
t2.start()  # 启动另一个线程

实例1：

import threading
import timedef foo(n):print("foo%s"%n)time.sleep(1)def bar(n):print("bar%s"%n)time.sleep(2)t1 = threading.Thread(target=foo,args=(1,))
t2 = threading.Thread(target=bar,args=(2,))t1.start()
t2.start()print("...in the main...")

结果：

程序启动后，主线程从上到下依次执行，t1、t2两个子线程启动后，与主线程并行，抢占CPU资源。因此，前三行的输出结果几乎同时打印，没有先后顺序，此时，需要等t1和t2都结束后程序才结束。故等待2s后，程序结束。程序总共花了2s。

foo1
bar2
...in the main...Process finished with exit code 0

实例2：

 import threadingfrom time import ctime,sleepimport timedef music(func):for i in range(2):print ("Begin listening to %s. %s" %(func,ctime()))sleep(4)print("end listening %s"%ctime())def move(func):for i in range(2):print ("Begin watching at the %s! %s" %(func,ctime()))sleep(5)print('end watching %s'%ctime())threads = []t1 = threading.Thread(target=music,args=('周杰伦',))threads.append(t1)t2 = threading.Thread(target=move,args=('梁朝伟',))threads.append(t2)if __name__ == '__main__':for t in threads:t.start()print ("all over %s" %ctime())

结果：

Begin listening to 周杰伦. Thu Sep 29 14:21:55 2016
Begin watching at the 梁朝伟! Thu Sep 29 14:21:55 2016
all over Thu Sep 29 14:21:55 2016
end listening Thu Sep 29 14:21:59 2016
Begin listening to 周杰伦. Thu Sep 29 14:21:59 2016
end watching Thu Sep 29 14:22:00 2016
Begin watching at the 梁朝伟! Thu Sep 29 14:22:00 2016
end listening Thu Sep 29 14:22:03 2016
end watching Thu Sep 29 14:22:05 2016Process finished with exit code 0

四、join（）

在子线程执行完成之前，这个子线程的父线程将一直被阻塞。就是说，当调用join（）的子进程没有结束之前，主进程不会往下执行。对其它子进程没有影响。

实例1：

import threading
from time import ctime,sleep
import timedef music(func):for i in range(2):print ("Begin listening to %s. %s" %(func,ctime()))sleep(4)print("end listening %s"%ctime())def move(func):for i in range(2):print ("Begin watching at the %s! %s" %(func,ctime()))sleep(5)print('end watching %s'%ctime())threads = []
t1 = threading.Thread(target=music,args=('七里香',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('阿甘正传',))
threads.append(t2)if __name__ == '__main__':for t in threads:t.start()t.join()print ("all over %s" %ctime())

结果解析：

t1线程启动→Begin listening→4s后end listening + Begin listening →4s后t2线程启动end listening t1结束 + Begin watching→5s后end listening + Begin watching→5s后end listening t2结束+ all over最后主进程结束。 就是酱紫，有点乱。。。

Begin listening to 七里香. Thu Sep 29 15:00:09 2016
end listening Thu Sep 29 15:00:13 2016
Begin listening to 七里香. Thu Sep 29 15:00:13 2016
end listening Thu Sep 29 15:00:17 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:00:17 2016
end watching Thu Sep 29 15:00:22 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:00:22 2016
end watching Thu Sep 29 15:00:27 2016
all over Thu Sep 29 15:00:27 2016

实例2：

import threading
from time import ctime,sleep
import timedef music(func):for i in range(2):print ("Begin listening to %s. %s" %(func,ctime()))sleep(4)print("end listening %s"%ctime())def move(func):for i in range(2):print ("Begin watching at the %s! %s" %(func,ctime()))sleep(5)print('end watching %s'%ctime())threads = []
t1 = threading.Thread(target=music,args=('七里香',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('阿甘正传',))
threads.append(t2)if __name__ == '__main__':for t in threads:t.start()t.join()        #for循环的最后一次t的值,相当于t2print ("all over %s" %ctime()

结果：

Begin listening to 七里香. Thu Sep 29 15:16:41 2016　#t1和t2线程启动
Begin watching at the 阿甘正传! Thu Sep 29 15:16:41 2016
end listening Thu Sep 29 15:16:45 2016
Begin listening to 七里香. Thu Sep 29 15:16:45 2016
end watching Thu Sep 29 15:16:46 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:16:46 2016
end listening Thu Sep 29 15:16:49 2016　#t1结束
end watching Thu Sep 29 15:16:51 2016　#t2结束，t2结束之前，主线程一直被阻塞。t2结束主线程继续执行
all over Thu Sep 29 15:16:51 2016　#主线程结束

实例3：

import threading
from time import ctime,sleep
import timedef music(func):for i in range(2):print ("Begin listening to %s. %s" %(func,ctime()))sleep(4)print("end listening %s"%ctime())def move(func):for i in range(2):print ("Begin watching at the %s! %s" %(func,ctime()))sleep(5)print('end watching %s'%ctime())threads = []
t1 = threading.Thread(target=music,args=('七里香',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('阿甘正传',))
threads.append(t2)if __name__ == '__main__':for t in threads:t.start()t1.join()        #当t1调用join()时print ("all over %s" %ctime())

结果：

Begin listening to 七里香. Thu Sep 29 15:35:35 2016　　　　#t1和t2启动
Begin watching at the 阿甘正传! Thu Sep 29 15:35:35 2016
end listening Thu Sep 29 15:35:39 2016
Begin listening to 七里香. Thu Sep 29 15:35:39 2016
end watching Thu Sep 29 15:35:40 2016
Begin watching at the 阿甘正传! Thu Sep 29 15:35:40 2016
end listening Thu Sep 29 15:35:43 2016　　　　#t1结束，主线程继续往下执行
all over Thu Sep 29 15:35:43 2016　　　　　　#主线程结束
end watching Thu Sep 29 15:35:45 2016　　　　#t2结束

五、setDaemon(True)

将线程声明为守护线程，必须在start() 方法调用之前设置， 如果不设置为守护线程程序会被无限挂起。这个方法基本和join是相反的。当我们 在程序运行中，执行一个主线程，如果主线程又创建一个子线程，主线程和子线程 就兵分两路，分别运行，那么当主线程完成想退出时，会检验子线程是否完成。如 果子线程未完成，则主线程会等待子线程完成后再退出。但是有时候我们需要的是 只要主线程完成了，不管子线程是否完成，都要和主线程一起退出，这时就可以用setDaemon方法。

实例：

import threading
from time import ctime,sleep
import timedef music(func):for i in range(2):print ("Begin listening to %s. %s" %(func,ctime()))sleep(4)print("end listening %s"%ctime())def move(func):for i in range(2):print ("Begin watching at the %s! %s" %(func,ctime()))sleep(5)print('end watching %s'%ctime())threads = []
t1 = threading.Thread(target=music,args=('七里香',))
threads.append(t1)
t2 = threading.Thread(target=move,args=('阿甘正传',))
threads.append(t2)if __name__ == '__main__':for t in threads:t.setDaemon(True)t.start()print ("all over %s" %ctime())

结果：

Begin listening to 七里香. Thu Sep 29 15:45:32 2016　#t1和t2启动，分别打印一次后sleep，主进程继续
Begin watching at the 阿甘正传! Thu Sep 29 15:45:32 2016
all over Thu Sep 29 15:45:32 2016　　　#主进程结束，程序结束

六、current_thread()

获取当前进程的名称。

七、同步锁

import time
import threadingdef addNum():global num #在每个线程中都获取这个全局变量# num-=1temp=numprint('--get num:',num )#time.sleep(0.1)num =temp-1 #对此公共变量进行-1操作num = 100  #设定一个共享变量
thread_list = []
for i in range(100):t = threading.Thread(target=addNum)t.start()thread_list.append(t)for t in thread_list: #等待所有线程执行完毕t.join()print('final num:', num )

用num -= 1则最终结果没问题，这是因为完成这个操作太快了，在线程切换时间内。用中间变量temp进行赋值时出现问题，这是因为100个线程，每一个都没有执行完就就行了切换，因此最终得到的不是0。

多个线程同时操作同一个共享资源，所以导致冲突，这种情况就需要用同步锁来解决。

import time
import threadingdef addNum():global num #在每个线程中都获取这个全局变量# num-=1lock.acquire()　　　　#加同步锁temp=numprint('--get num:',num )#time.sleep(0.1)num =temp-1 #对此公共变量进行-1操作lock.release()　　　　#解锁num = 100  #设定一个共享变量
thread_list = []
lock=threading.Lock()　　#创建lock对象for i in range(100):t = threading.Thread(target=addNum)t.start()thread_list.append(t)for t in thread_list: #等待所有线程执行完毕t.join()　　　　　　#所有线程执行完后主程序才能结束print('final num:', num )

GIL与同步锁的作用对比：

GIL：同一时刻只能有一个线程进入解释器。

同步锁：同一时刻，保证只有一个线程被执行，在局部保证操作共享资源时不会发生冲突。

八、线程死锁和递归锁

所谓死锁： 是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 由于资源占用是互斥的，当某个进程提出申请资源后，使得有关进程在无外力协助下，永远分配不到必需的资源而无法继续运行，这就产生了一种特殊现象死锁。

实例：

import threading,timeclass myThread(threading.Thread):def doA(self):lockA.acquire()print(self.name,"gotlockA",time.ctime())time.sleep(3)lockB.acquire()print(self.name,"gotlockB",time.ctime())lockB.release()lockA.release()def doB(self):lockB.acquire()print(self.name,"gotlockB",time.ctime())time.sleep(2)lockA.acquire()print(self.name,"gotlockA",time.ctime())lockA.release()lockB.release()def run(self):self.doA()self.doB()
if __name__=="__main__":lockA=threading.Lock()lockB=threading.Lock()threads=[]for i in range(5):threads.append(myThread())for t in threads:t.start()for t in threads:t.join()#等待线程结束，后面再讲。

死锁解决办法：使用递归锁,创建Rlock对象，在需要加锁时使用

lockA=threading.Lock()
lockB=threading.Lock()lock = threading.Rlock()

 


http://chatgpt.dhexx.cn/article/eqPgdC7J.shtml

相关文章

python中threading模块_python中threading模块详解

python中threading模块_python中threading模块详解

python中threading模块详解，threading提供了一个比thread模块更高层的API来提供线程的并发性。这些线程并发运行并共享内存。 下面来看threading模块的具体用法： 一、Thread的使用 目标函数可以实例化一个Thread对象，每个Thread对象代表着一个线程，可以通过start()方法，开…
阅读更多...
python中的threading_python中threading的用法

python中的threading_python中threading的用法

threading提供了一个比thread模块更高层的API来提供线程的并发性。这些线程并发运行并共享内存。 下面来看threading模块的具体用法： 一、Thread的使用 目标函数可以实例化一个Thread对象，每个Thread对象代表着一个线程，可以通过start()方法…
阅读更多...
Python--threading多线程总结

Python--threading多线程总结

转载自：https://www.cnblogs.com/tkqasn/p/5700281.html threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。python当前版本的多线程库没有实现优先级、线程组，线程也不能被停止、暂停、恢复、中断。 threading模块提供的类&…
阅读更多...
Python 批量创建线程及threading.Thread类的常用函数及方法

Python 批量创建线程及threading.Thread类的常用函数及方法

在《【Python】线程的创建、执行、互斥、同步、销毁》（点击打开链接）中介绍了Python中线程的使用，但是里面线程的创建，使用了很原始的方式，一行代码创建一条。其实，Python里是可以批量创建线程的。利用Pyth…
阅读更多...
功能强大的python包（十一）：threading （多线程）

功能强大的python包（十一）：threading （多线程）

1.threading简介 threading库是python的线程模型，利用threading库我们可以轻松实现多线程任务。 2.进程与线程简介 通过上图，我们可以直观的总结出进程、线程及其之间的关系与特点： 进程是资源分配的最小单元，一个程序至少包含…
阅读更多...
一文搞明白Python多线程编程：threading库

一文搞明白Python多线程编程：threading库

目录 前言一、基础知识1、并行和并发（1）定义（2）联系 2、进程和线程（1）定义（2）联系 3、全局解释器锁GIL 二、threading库1、线程的使用（1）普通创建方式&#x…
阅读更多...
分块矩阵求逆（推导）

分块矩阵求逆（推导）

关于分块矩阵求逆，其中对角矩阵比较简单，我看很多人都写了，并且很详细。 但关于AUVD的分块矩阵我没看到太让我明白的，可能我get不到点，数学基础差，我就自己写了详细的步骤。 我写的这个条件是A可逆&#…
阅读更多...
伴随矩阵求逆矩阵

伴随矩阵求逆矩阵

在之前的文章《线性代数之矩阵》中已经介绍了一些关于矩阵的基本概念，本篇文章主要就求解逆矩阵进行进一步总结。 余子式(Minor) 我们先看例子来直观的理解什么是余子式(Minor，后边将都用英文Minor，中文的翻译较乱）。 minor exa…
阅读更多...
矩阵的逆

矩阵的逆

矩阵的逆 原理&#xff1a; 连接&#xff1a; https://baike.baidu.com/item/%E9%80%86%E7%9F%A9%E9%98%B5 代码&#xff1a; QT c版&#xff1a; //求逆矩阵 QVector<QVector<double>> Matrix_inverse(QVector<QVector<double>> &A) {int …
阅读更多...
矩阵求逆

矩阵求逆

矩阵求逆 初等变换求逆参考文章 初等变换求逆 1&#xff09;初等变换求逆矩阵时不能同时使用初等列变换和初等行变换&#xff0c;使用初等列变换或者初等行变换来求逆矩阵都是可以的&#xff0c;但是不能二者同时使用&#xff0c;只能用一种方法来得到逆矩阵。 2&#xff09;初…
阅读更多...
卡西欧计算器矩阵求逆

卡西欧计算器矩阵求逆

记录一下&#xff0c;防止忘记 1 按开机键 打开计算器 2 按 菜单设置键 进去计算模式选择模块 3 按“ 4 ”选择矩阵运算 4 有四个矩阵可以编辑 选择按 4 编辑矩阵D 5 输入矩阵的行数 我按了3 6 输入矩阵的列数 我按了 3 7 建了一个3*3空矩阵 输入第一个数 12 然后按“”键完…
阅读更多...
如何用计算机求矩阵的逆矩阵,逆矩阵的求法

如何用计算机求矩阵的逆矩阵,逆矩阵的求法

逆矩阵是数学知识的一种&#xff0c;很多学习数学的同学们应该很了解吧。逆矩阵计算器是一款可以对矩阵的逆进行计算的免费程序,本程序引入了分数算法,可以对分数元素计算并得出分数结果。那么这款软件怎么样呢&#xff1f;接下来&#xff0c;介绍一下。 逆矩阵的求法 A^(-1)(1…
阅读更多...
python求逆矩阵的方法,Python 如何求矩阵的逆

python求逆矩阵的方法,Python 如何求矩阵的逆

我就废话不多说了，大家还是直接看代码吧~ import numpy as np kernel = np.array([1, 1, 1, 2]).reshape((2, 2)) print(kernel) print(np.linalg.inv(kernel)) 注意，Singular matrix奇异矩阵不可求逆 补充：python+numpy中矩阵的逆和伪逆的区别 定义： 对于矩阵A，如果存在一…
阅读更多...
Maple矩阵求逆

Maple矩阵求逆

如何使用Maple进行矩阵求逆 调用包 with(LineAlgebra);输入我想要的矩阵&#xff1a; R : Matrix([[cos(a), sin(a), 0], [-sin(a), cos(a), 0], [0, 0, 1]]);然后我使用了Inverse命令 simplify(Inverse(R));结果并没有生成矩阵的逆。 查了一下说明手册加上mod好像也不行&a…
阅读更多...
线性代数 --- 矩阵求逆的4种方法

线性代数 --- 矩阵求逆的4种方法

线性代数 --- 矩阵求逆的4种方法 写在最前面&#xff1a;在大多数情况下&#xff0c;我们学习线性代数的目的是为了求解线性方程组Axb&#xff0c;而不是为了求A的逆。 单就解方程而言&#xff0c;LU分解是最实用的算法。只需按照ALU——>Axb,LUxb——>Lyb(正向回代求得y…
阅读更多...
求解逆矩阵的常用三种方法

求解逆矩阵的常用三种方法

1.待定系数法 矩阵A 1, 2 -1,-3 假设所求的逆矩阵为 a,b c,d 则 从而可以得出方程组 a 2c 1 b 2d 0 -a - 3c 0 -b - 3d 1 解得 a3; b2; c -1; d -1 2.方程组求逆矩阵 伴随矩阵是矩阵元素所对应的代数余子式&#xff0c;所构成的矩阵&#xff0c;转置后得到的新矩阵。 …
阅读更多...
矩阵求逆四种方法

矩阵求逆四种方法

注&#xff1a; 用A、B表示某矩阵, E表示单位矩阵 用Aˊ表示A逆 用|A|表示A的行列式 &#xff3b;A|E&#xff3d;表示拼接矩阵 一、公式法 先求A行列式结果&#xff0c;再求A伴随矩阵&#xff0c;最后再求A逆矩阵 |A| &#xff01; 0 则 AˊA*/|A| 注&#xff1a;图片中det…
阅读更多...
浏览器渲染页面和加载页面机制

浏览器渲染页面和加载页面机制

为什么有些网站打开的时候会加载会很慢&#xff0c;而且是整个页面同时显示的&#xff0c;而有些网站是从顶到下逐步显示出来的&#xff1f;弄懂这些对前端性能优化有很大帮助。要搞懂这个可以先从下面这个常规流程开始&#xff1a; 常规流程 1. 浏览器下载的顺序是从上到下&am…
阅读更多...
页面实现加载进度条

页面实现加载进度条

文章目录 一、定时器实现进度条二、css3实现进度条三、加载状态事件实现进度条 一、定时器实现进度条 原理&#xff1a;设置了固定的时间后将图片和遮罩层隐藏,显示出页面的内容 效果1&#xff1a; 定时器实现的进度条效果 代码实现 <!DOCTYPE html> <html langen>…
阅读更多...
VUE页面中加载外部HTML

VUE页面中加载外部HTML

方法1&#xff0c;用iframe vue页面 <template><button click"invokeHtmlMethod">调用html种方法</button><div class"iframestyleset"><iframe name "iframeMap" id"iframeMapViewComponent" v-bind…
阅读更多...
推荐文章

Copyright @ 2022~2023