【python学习】Python 线程编程（类内多线程编程）

2023-12-01 23:12
文章标签 python 线程 学习 多线程 编程 类内

本文主要是介绍【python学习】Python 线程编程（类内多线程编程），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Python线程编程（类内多线程编程）

文章目录

  • Python线程编程（类内多线程编程）
    • 多线程编程的函数
    • Function级多线程编程
    • class级多线程编程
      • 进阶 类内多线程

多线程可以同时执行一段代码的多个程序。使用多线程可能使程序运行速度更快。

线程和进程不同：可以这样来简单理解，一个程序包含一个或多个进程，一个进程包含一个或多个线程。也就是说程序 > 进程 > 线程。进程之间、线程之间、进程和线程之间可以共享数据。线程也被称为轻量级进程。

线程是操作系统能够运行的最小单位，线程包含在进程中，是进程中的实际运作单位。

Python 线程编程提供了两个模块，即 _thread和threading，其中 _thread是低级模块，threading 是高级模块，它对 _thread模块进行了封装。

import threading
# 或者
from threading import thread

python 多线程编程方法主要有两种，一种是针对Function的，一种是针对Class的。

多线程编程的函数

Thread创建线程Thread(target,args)
方法名说明用法
start启动线程start()
join阻塞直到线程执行结束join(timeout=None)
run用来重载，表示线程活动的方法run()
getName获取线程的名字getName()
setName设置线程的名字setName(name)
is_alive判读线程是否存活is_alive()
setDaemon守护线程setDaemon(True)

Function级多线程编程

Function级别多线程主要是调用Thread模块，Thread模块在Threading库中，Thread本身也是一个类class

该类的接口为

Thread(target, name, args, [kwargs])

target表示一个可调用的对象，可以是一个函数function。

name表示线程的名字，默认创建一个Thread-N格式的唯一名称。

如果target是一个带有参数的函数，则需要使用到args或[kwargs]。

from threading import Thread
t1 = Thread(target=function_name)

上述代码，就是初始化了一个Thread类的对象，其中function_name填写自己的函数名称，这样就新建了一个该函数的线程。

我们可以使用for循环初始化多个线程

from threading import Thread
def task(value):print("I am ", value)time.sleep(3)

一个稍微复杂一点的程序：

list_a = [0, 0, 0, 0, 0, 0]
def task(value):list_a[value] += valueprint("[%s] %s 修改第 %d 个值，修改后值为:%d" % (time.ctime(time.time()), threading.current_thread().name, value, list_a[value]))print("--------------程序开始--------------")
threads_pool = []
for i in range(len(list_a)):t = Thread(target=task,name=i, kwargs={"value": i})   # 初始化6个线程threads_pool.append(t)# 第一个for循环更高级的写法是
threads_pool = [Thread(target=task,name=i, kwargs={"value": i}) for i in range(len(list_a))]# 初始化的线程需要start命令启动，start会自动调用线程中的run命令运行
for t in threads_pool:t.start()for t in threads_pool:t.join()print("---------------程序结束------------")

输出：

--------------程序开始--------------
[Fri Dec  1 21:41:13 2023] Thread-1 修改第 0 个值，修改后值为:0
[Fri Dec  1 21:41:13 2023] 1 修改第 1 个值，修改后值为:1
[Fri Dec  1 21:41:13 2023] 2 修改第 2 个值，修改后值为:2
[Fri Dec  1 21:41:13 2023] 3 修改第 3 个值，修改后值为:3
[Fri Dec  1 21:41:13 2023] 4 修改第 4 个值，修改后值为:4
[Fri Dec  1 21:41:13 2023] 5 修改第 5 个值，修改后值为:5
---------------程序结束------------

注意：看来线程的名字不能被命名为数字0。

上面一个稍微复杂的代码共开了六个线程，每个线程对指定为的list_a数组进行加值的操作，

class级多线程编程

class级多线程编程通过定义一个继承Thread线程类的子类来创建线程。

继承于threading.Thread类的子类，需要对init等方法进行重写：

该段代码来自Python 多线程 | 菜鸟教程 (runoob.com)

import threading
import time
from threading import Thread# list = [0,0,0,0,0,0,0,0,0,0,0,0]
class myThread(threading.Thread):def __init__(self,threadId,name,counter):threading.Thread.__init__(self)self.threadId = threadIdself.name = nameself.counter = counterglobal listlist = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]def run(self):print ("开始线程:",self.name)# 获得锁，成功获得锁定后返回 True# 可选的timeout参数不填时将一直阻塞直到获得锁定# 否则超时后将返回 False# threadLock.acquire()print_time(self.name,self.counter,list.__len__())# 释放锁# threadLock.release()def __del__(self):print (self.name,"线程结束！")
def print_time(threadName,delay,counter):while counter:time.sleep(delay)list[counter-1] += 1print("[%s] %s 修改第 %d 个值，修改后值为:%d" % (time.ctime(time.time()),threadName,counter,list[counter-1]))counter -= 1threadLock = threading.Lock()
threads = []
# 创建新线程
thread1 = myThread(1,"Thread-1",1)
thread2 = myThread(2,"Thread-2",2)
thread3 = myThread(3, "Thread-3",3)
# 开启新线程
thread1.start()
thread2.start()
thread3.start()
# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)
threads.append(thread3)
# 等待所有线程完成
for t in threads:t.join()
print("主进程结束！")
print("list:", list)

该段代码实现了对Thread继承的一个类，并重写了run()函数。

输出如下：

开始线程: Thread-1
开始线程: Thread-2
开始线程: Thread-3
[Fri Dec  1 21:56:13 2023] Thread-1 修改第 12 个值，修改后值为:1
[Fri Dec  1 21:56:14 2023] Thread-1 修改第 11 个值，修改后值为:1
[Fri Dec  1 21:56:14 2023] Thread-2 修改第 12 个值，修改后值为:2
[Fri Dec  1 21:56:15 2023] Thread-3 修改第 12 个值，修改后值为:3
[Fri Dec  1 21:56:15 2023] Thread-1 修改第 10 个值，修改后值为:1
[Fri Dec  1 21:56:16 2023] Thread-1 修改第 9 个值，修改后值为:1[Fri Dec  1 21:56:16 2023] Thread-2 修改第 11 个值，修改后值为:2[Fri Dec  1 21:56:17 2023] Thread-1 修改第 8 个值，修改后值为:1
[Fri Dec  1 21:56:18 2023] Thread-3 修改第 11 个值，修改后值为:3
[Fri Dec  1 21:56:18 2023] Thread-2 修改第 10 个值，修改后值为:2
[Fri Dec  1 21:56:18 2023] Thread-1 修改第 7 个值，修改后值为:1
[Fri Dec  1 21:56:19 2023] Thread-1 修改第 6 个值，修改后值为:1
[Fri Dec  1 21:56:20 2023] Thread-2 修改第 9 个值，修改后值为:2
[Fri Dec  1 21:56:20 2023] Thread-1 修改第 5 个值，修改后值为:1
[Fri Dec  1 21:56:21 2023] Thread-3 修改第 10 个值，修改后值为:3
[Fri Dec  1 21:56:21 2023] Thread-1 修改第 4 个值，修改后值为:1
[Fri Dec  1 21:56:22 2023] Thread-2 修改第 8 个值，修改后值为:2
[Fri Dec  1 21:56:22 2023] Thread-1 修改第 3 个值，修改后值为:1
[Fri Dec  1 21:56:23 2023] Thread-1 修改第 2 个值，修改后值为:1
[Fri Dec  1 21:56:24 2023] Thread-3 修改第 9 个值，修改后值为:3
[Fri Dec  1 21:56:24 2023] Thread-2 修改第 7 个值，修改后值为:2
[Fri Dec  1 21:56:24 2023] Thread-1 修改第 1 个值，修改后值为:1
[Fri Dec  1 21:56:26 2023] Thread-2 修改第 6 个值，修改后值为:2
[Fri Dec  1 21:56:27 2023] Thread-3 修改第 8 个值，修改后值为:3
[Fri Dec  1 21:56:28 2023] Thread-2 修改第 5 个值，修改后值为:2
[Fri Dec  1 21:56:30 2023] Thread-3 修改第 7 个值，修改后值为:3
[Fri Dec  1 21:56:30 2023] Thread-2 修改第 4 个值，修改后值为:2
[Fri Dec  1 21:56:32 2023] Thread-2 修改第 3 个值，修改后值为:2
[Fri Dec  1 21:56:33 2023] Thread-3 修改第 6 个值，修改后值为:3
[Fri Dec  1 21:56:34 2023] Thread-2 修改第 2 个值，修改后值为:2
[Fri Dec  1 21:56:36 2023] Thread-3 修改第 5 个值，修改后值为:3
[Fri Dec  1 21:56:36 2023] Thread-2 修改第 1 个值，修改后值为:2
[Fri Dec  1 21:56:39 2023] Thread-3 修改第 4 个值，修改后值为:3
[Fri Dec  1 21:56:42 2023] Thread-3 修改第 3 个值，修改后值为:3
[Fri Dec  1 21:56:45 2023] Thread-3 修改第 2 个值，修改后值为:3
[Fri Dec  1 21:56:48 2023] Thread-3 修改第 1 个值，修改后值为:3
主进程结束！
list: [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
False
Thread-1 线程结束！
Thread-2 线程结束！
Thread-3 线程结束！Process finished with exit code 0

该段代码实现了，开3个线程，每个线程对list数组每个数据进行加1操作。

进阶 类内多线程

有的时候，我们可能在一个类class内部，再实现一个类class，该类被称为内部类，我们希望通过内部类来实现多线程，它的方法和外部类的方法总体比较相似，只要把内部类看作是self的一部分即可。

class Ant_Colony(object):class ant(Thread):def __init__(self, initital_location, ant_id):Thread.__init__(self)self.route = []self.initital_location = initital_locationself.id = ant_iddef run(self):print("开始线程 ant_id: ", self.id)self.calcute_route()def calcute_route(self):offsets = [(-1, 1), (0, 1), (1, 1), (-1, 0), (1, 0), (-1, -1), (0, -1), (1, -1)]cur_pos = self.initital_locationfor offset in offsets:pos_x = cur_pos[0] + offset[0]pos_y = cur_pos[1] + offset[1]if map[pos_x][pos_y] != 0 and pos_x >= 0 and \pos_x < 5 and pos_y >= 0 and pos_y < 5:pheromone[pos_x][pos_y] += 1print("ant_id = %d, pos_x = %d, pos_y = %d" % (self.id, pos_x, pos_y))else:continuedef __del__(self):print("ant_id ", self.id, " 线程结束！")def __init__(self, map, pheronome, ant_num):self.map = mapglobal pheromonepheromone = pheromone# self.pheromone = pheronomeself.ant_num = ant_numself.ants = self._init_ants()def _init_ants(self):return [self.ant([0, 1], i) for i in range(self.ant_num)]def run(self):for ant in self.ants:ant.start()for ant in self.ants:ant.join()self.print()def print(self):print("1")print("类内", pheromone)

输出：

类外： [[0.85956061 0.1645695  0.48347596 0.92102727 0.42855644][0.05746009 0.92500743 0.65760154 0.13295284 0.53344893][0.8994776  0.24836496 0.03017182 0.07244715 0.87416449][0.55843035 0.91604736 0.63346045 0.28325261 0.36536881][0.09223386 0.37251258 0.34742278 0.70517077 0.64850904]]
开始线程 ant_id:  0
ant_id = 0, pos_x = 0, pos_y = 2
ant_id = 0, pos_x = 1, pos_y = 2
ant_id = 0, pos_x = 1, pos_y = 1
ant_id = 0, pos_x = 0, pos_y = 0
ant_id = 0, pos_x = 1, pos_y = 0开始线程 ant_id:  1
ant_id = 1, pos_x = 0, pos_y = 2ant_id = 1, pos_x = 1, pos_y = 2开始线程 ant_id:  
ant_id = 1, pos_x = 1, pos_y = 1
ant_id = 1, pos_x = 0, pos_y = 0
ant_id = 1, pos_x = 1, pos_y = 0
2
ant_id = 2, pos_x = 0, pos_y = 2
ant_id = 2, pos_x = 1, pos_y = 2
ant_id = 2, pos_x = 1, pos_y = 1
ant_id = 2, pos_x = 0, pos_y = 0
ant_id = 2, pos_x = 1, pos_y = 0
1
类内 [[3.85956061 0.1645695  3.48347596 0.92102727 0.42855644][3.05746009 3.92500743 3.65760154 0.13295284 0.53344893][0.8994776  0.24836496 0.03017182 0.07244715 0.87416449][0.55843035 0.91604736 0.63346045 0.28325261 0.36536881][0.09223386 0.37251258 0.34742278 0.70517077 0.64850904]]
类外 [[3.85956061 0.1645695  3.48347596 0.92102727 0.42855644][3.05746009 3.92500743 3.65760154 0.13295284 0.53344893][0.8994776  0.24836496 0.03017182 0.07244715 0.87416449][0.55843035 0.91604736 0.63346045 0.28325261 0.36536881][0.09223386 0.37251258 0.34742278 0.70517077 0.64850904]]
ant_id  2  线程结束！
ant_id  1  线程结束！
ant_id  0  线程结束！

这篇关于【python学习】Python 线程编程（类内多线程编程）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/443060。

相关文章

python获取指定名字的程序的文件路径的两种方法

python获取指定名字的程序的文件路径的两种方法

《python获取指定名字的程序的文件路径的两种方法》本文主要介绍了python获取指定名字的程序的文件路径的两种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要... 最近在做项目，需要用到给定一个程序名字就可以自动获取到这个程序在Windows系统下的绝对路径，以下
阅读更多...
使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解

使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解

《使用Python批量将.ncm格式的音频文件转换为.mp3格式的实战详解》本文详细介绍了如何使用Python通过ncmdump工具批量将.ncm音频转换为.mp3的步骤,包括安装、配置ffmpeg环... 目录1. 前言2. 安装 ncmdump3. 实现 .ncm 转 .mp34. 执行过程5. 执行结
阅读更多...
Python实现批量CSV转Excel的高性能处理方案

Python实现批量CSV转Excel的高性能处理方案

《Python实现批量CSV转Excel的高性能处理方案》在日常办公中,我们经常需要将CSV格式的数据转换为Excel文件,本文将介绍一个基于Python的高性能解决方案,感兴趣的小伙伴可以跟随小编一... 目录一、场景需求二、技术方案三、核心代码四、批量处理方案五、性能优化六、使用示例完整代码七、小结一、
阅读更多...
Python中 try / except / else / finally 异常处理方法详解

Python中 try / except / else / finally 异常处理方法详解

《Python中try/except/else/finally异常处理方法详解》：本文主要介绍Python中try/except/else/finally异常处理方法的相关资料,涵... 目录1. 基本结构2. 各部分的作用tryexceptelsefinally3. 执行流程总结4. 常见用法（1）多个e
阅读更多...
Python中logging模块用法示例总结

Python中logging模块用法示例总结

《Python中logging模块用法示例总结》在Python中logging模块是一个强大的日志记录工具,它允许用户将程序运行期间产生的日志信息输出到控制台或者写入到文件中,：本文主要介绍Pyt... 目录前言一. 基本使用1. 五种日志等级2.  设置报告等级3. 自定义格式4. C语言风格的格式化方法
阅读更多...
Python实现精确小数计算的完全指南

Python实现精确小数计算的完全指南

《Python实现精确小数计算的完全指南》在金融计算、科学实验和工程领域,浮点数精度问题一直是开发者面临的重大挑战,本文将深入解析Python精确小数计算技术体系,感兴趣的小伙伴可以了解一下... 目录引言：小数精度问题的核心挑战一、浮点数精度问题分析1.1 浮点数精度陷阱1.2 浮点数误差来源二、基础解决
阅读更多...
使用Python实现Word文档的自动化对比方案

使用Python实现Word文档的自动化对比方案

《使用Python实现Word文档的自动化对比方案》我们经常需要比较两个Word文档的版本差异,无论是合同修订、论文修改还是代码文档更新,人工比对不仅效率低下,还容易遗漏关键改动,下面通过一个实际案例... 目录引言一、使用python-docx库解析文档结构二、使用difflib进行差异比对三、高级对比方
阅读更多...
深度解析Python中递归下降解析器的原理与实现

深度解析Python中递归下降解析器的原理与实现

《深度解析Python中递归下降解析器的原理与实现》在编译器设计、配置文件处理和数据转换领域,递归下降解析器是最常用且最直观的解析技术,本文将详细介绍递归下降解析器的原理与实现,感兴趣的小伙伴可以跟随... 目录引言：解析器的核心价值一、递归下降解析器基础1.1 核心概念解析1.2 基本架构二、简单算术表达
阅读更多...
从入门到精通详解Python虚拟环境完全指南

从入门到精通详解Python虚拟环境完全指南

《从入门到精通详解Python虚拟环境完全指南》Python虚拟环境是一个独立的Python运行环境,它允许你为不同的项目创建隔离的Python环境,下面小编就来和大家详细介绍一下吧... 目录什么是python虚拟环境一、使用venv创建和管理虚拟环境1.1 创建虚拟环境1.2 激活虚拟环境1.3 验证虚
阅读更多...
详解python pycharm与cmd中制表符不一样

详解python pycharm与cmd中制表符不一样

《详解pythonpycharm与cmd中制表符不一样》本文主要介绍了pythonpycharm与cmd中制表符不一样,这个问题通常是因为PyCharm和命令行（CMD）使用的制表符（tab）的宽... 这个问题通常是因为PyCharm和命令行（CMD）使用的制表符（tab）的宽度不同导致的。在PyChar
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2