【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] += value
print("[%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 = threadId
self.name = name
self.counter = counter
global list
list = [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] += 1
print("[%s] %s 修改第 %d 个值，修改后值为:%d" % (time.ctime(time.time()),threadName,counter,list[counter-1]))
counter -= 1
threadLock = 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_location
self.id = ant_id
def 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_location
for 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] += 1
print("ant_id = %d, pos_x = %d, pos_y = %d" % (self.id, pos_x, pos_y))
else:
continue
def __del__(self):
print("ant_id ", self.id, " 线程结束！")
def __init__(self, map, pheronome, ant_num):
self.map = map
global pheromone
pheromone = pheromone
# self.pheromone = pheronome
self.ant_num = ant_num
self.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 = 2
ant_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 线程结束！