多线程（Multithreading），是指从软件或者硬件上实现多个线程并发执行的技术。具有多线程能力的系统包括对称多处理机、多核心处理器、芯片级多处理或同时多线程处理器。在一个程序中，这些独立运行的程序片段叫作 “线程”（Thread），利用它编程的概念就叫作 “多线程处理”。
多线程是并行化的一种形式，或者是拆分工作以便同时进行处理。线程化的程序将工作拆分到多个软件线程，而不是将大量工作交给单个内核。这些线程由不同的 CPU 内核并行处理，以节省时间。
多线程运行有如下优点：
(1) 使用线程可以把占据长时间的程序中的任务放到后台去处理；
(2) 用户界面可以更加吸引人，比如用户点击了一个按钮去触发某些事件的处理，可以弹出一个进度条来显示处理的进度；
(3) 程序的运行速度可能加快；
(4) 在一些等待的任务实现上如用户输入、文件读写和网络收发数据等，线程就比较有用了。
线程可以分为:
(1) 内核线程：由操作系统内核创建和撤销。
(2) 用户线程：不需要内核支持而在用户程序中实现的线程。
并行和并发的区别：
并行（Parallelism）：是同一时刻，每个线程都在执行。
并发（Concurrency）：是同一时刻，只有一个线程执行，然后交替执行。Python 多线程是并发的。
Python 中与多线程相关的 2 个模块：
(1) _thread
(2) threading (推荐使用)
注：thread 模块已被废弃。用户可以使用 threading 模块代替。所以，在 Python3 中不能再使用 "thread" 模块。为了兼容性，Python3 将 thread 重命名为 "_thread"。
1. _thread 模块
_thread 模块提供低级别的接口，用于支持轻量级的多线程开发，也提供了简单的锁机制（也称为 互斥锁 或 二进制信号）。
调用 _thread 模块中的 start_new_thread( )函数来产生新线程。语法格式如下:
_thread.start_new_thread(function, args[, kwargs])
参数说明:
function - 线程函数。
args - 传递给线程函数的参数,他必须是个tuple类型。
kwargs - 可选参数。
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import _thread
import time
def print_time( name, delay):
count = 0
while count < 3:
time.sleep(delay)
count += 1
print ("%s: %s" % ( name, time.ctime(time.time()) ))
print("%s 结束" % name)
_thread.start_new_thread(print_time, ("Thread-1", 2))
_thread.start_new_thread(print_time, ("Thread-2", 4))
print("同时按下 Ctrl + C 键退出")
while True:
pass
输出结果如下：
同时按下 Ctrl + C 键退出
Thread-1: Sat Aug 24 13:02:54 2024
Thread-2: Sat Aug 24 13:02:56 2024
Thread-1: Sat Aug 24 13:02:56 2024
Thread-1: Sat Aug 24 13:02:58 2024
Thread-1 结束
Thread-2: Sat Aug 24 13:03:00 2024
Thread-2: Sat Aug 24 13:03:04 2024
Thread-2 结束
Traceback (most recent call last):
File "d:/pythonDemo/thread.py", line 23, in <module>
pass
KeyboardInterrupt
注：两个线程结束后，主程序仍然处于 while True 循环阻塞，需要在控制台按下 Ctrl + C 键才能退出。
显然，while True 循环阻塞不是很好的线程同步方式，我们可以使用 _thread.allocate_lock() 来实现线程同步，修改代码如下：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import _thread
import time
def print_time( name, delay, lock):
count = 0
while count < 3:
time.sleep(delay)
count += 1
print ("%s: %s" % ( name, time.ctime(time.time()) ))
print("%s 结束" % name)
lock.release()
lock1 = _thread.allocate_lock()
lock1.acquire()
_thread.start_new_thread(print_time, ("Thread-1", 2, lock1))
lock2 = _thread.allocate_lock()
lock2.acquire()
_thread.start_new_thread(print_time, ("Thread-2", 4, lock2))
while lock1.locked() or lock2.locked():
pass
输出结果如下：
Thread-1: Sat Aug 24 17:24:14 2024
Thread-2: Sat Aug 24 17:24:16 2024
Thread-1: Sat Aug 24 17:24:16 2024
Thread-1: Sat Aug 24 17:24:18 2024
Thread-1 结束
Thread-2: Sat Aug 24 17:24:20 2024
Thread-2: Sat Aug 24 17:24:24 2024
Thread-2 结束
注：两个线程结束后，主程序自动退出。
2. threading 模块
threading 模块除了包含 _thread 模块中的所有方法外，还提供如下方法：
(1) threading.Thread(target, args=(), kwargs={}, daemon=None): 创建 Thread 类的实例；
(2) threading.current_thread(): 返回当前的线程变量；
(3) threading.enumerate(): 返回一个包含正在运行的线程的列表。正在运行指线程启动后、结束前，不包括启动前和终止后的线程；
(4) threading.active_count(): 返回正在运行的线程数量，与 len(threading.enumerate()) 有相同的结果；
threading.Thread() 返回的 Thread 实例包含如下方法与属性:
(1) start()：开始线程活动(只能执行一次)；
(2) run()：线程的方法，在线程被 cpu 调度后，就会自动执行这个方法，可以重写；
(3) join()：等待，直到线程结束；
(4) setName()：给线程设置名字；
(5) getName()：获取线程名字；
(6) is_alive()：返回线程是否存活( True 或者 False)；
(7) daemon: 守护线程，默认是 False；
1) 使用 threading.Thread() 创建线程
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import threading
import time
def print_time( name, delay):
count = 0
while count < 3:
time.sleep(delay)
count += 1
print ("%s: %s" % ( name, time.ctime(time.time()) ))
print("%s finish" % name)
thread1 = threading.Thread(target=print_time, args=("Thread-1", 2))
thread2 = threading.Thread(target=print_time, args=("Thread-2", 4))
thread1.start()
thread2.start()
print('主程序结束')
输出结果如下：
主程序结束
Thread-1: Sat Aug 24 14:05:32 2024
Thread-2: Sat Aug 24 14:05:34 2024
Thread-1: Sat Aug 24 14:05:34 2024
Thread-1: Sat Aug 24 14:05:36 2024
Thread-1 结束
Thread-2: Sat Aug 24 14:05:38 2024
Thread-2: Sat Aug 24 14:05:42 2024
Thread-2 结束
2) 继承 threading.Thread 创建子类线程
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import threading
import time
class TestThread(threading.Thread):
def __init__(self, name, delay):
super().__init__()
self.name = name
self.delay = delay
def run(self):
print_time(self.name, self.delay)
print("%s 结束" % self.name)
def print_time( name, delay):
count = 0
while count < 3:
time.sleep(delay)
count += 1
print ("%s: %s" % ( name, time.ctime(time.time()) ))
start = time.time()
thread1 = TestThread("Thread-1", 2)
thread2 = TestThread("Thread-2", 4)
thread1.start()
thread2.start()
# 等待线程都结束
thread1.join()
thread2.join()
end = time.time()
print('主程序结束', int(end-start), '秒')
输出结果如下：
Thread-1: Sat Aug 24 17:40:40 2024
Thread-2: Sat Aug 24 17:40:42 2024
Thread-1: Sat Aug 24 17:40:42 2024
Thread-1: Sat Aug 24 17:40:44 2024
Thread-1 结束
Thread-2: Sat Aug 24 17:40:46 2024
Thread-2: Sat Aug 24 17:40:50 2024
Thread-2 结束
主程序结束 12 秒
注：在主程序里调用线程的 join() 方法，实现多个线程的同步。
3. 线程锁
有些场景我们不希望多个线程同时读写同一个数据，为了保证数据的正确性，需要管理线程对数据读写。
可以使用 threading 模块的 Lock 或 Rlock 线程锁，两者都有 acquire 方法和 release 方法，可以将数据的读写操作放在 acquire 和 release 方法之间。
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import threading
import time
class TestThread(threading.Thread):
def __init__(self, name, delay):
super().__init__()
self.name = name
self.delay = delay
def run(self):
threadLock.acquire()
print_time(self.name, self.delay)
print("%s 结束" % self.name)
threadLock.release()
def print_time( name, delay):
count = 0
while count < 3:
time.sleep(delay)
count += 1
print ("%s: %s" % ( name, time.ctime(time.time()) ))
threadLock = threading.Lock()
start = time.time()
thread1 = TestThread("Thread-1", 2)
thread2 = TestThread("Thread-2", 4)
thread1.start()
thread2.start()
thread1.join()
thread2.join()
end = time.time()
print('主程序结束', int(end-start), '秒')
输出结果如下：
Thread-1: Sat Aug 24 18:42:01 2024
Thread-1: Sat Aug 24 18:42:03 2024
Thread-1: Sat Aug 24 18:42:05 2024
Thread-1 结束
Thread-2: Sat Aug 24 18:42:09 2024
Thread-2: Sat Aug 24 18:42:13 2024
Thread-2: Sat Aug 24 18:42:17 2024
Thread-2 结束
主程序结束 18 秒
注：使用了线程锁之后，Thread-2 等 Thread-1 结束后才开始操作数据，程序总用时比没使用线程锁时增加了 6 秒。
4. 守护线程
使用 threading 模块创建的线程，有两种类型：守护线程（Daemon thread）和非守护线程（Non-daemon thread）。默认情况下，当主线程结束时，所有非守护线程会继续运行。而守护线程会在主线程结束时自动退出。
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import threading
import time
def print_time( name, delay):
while True:
time.sleep(delay)
print ("%s: %s" % ( name, time.ctime(time.time()) ))
thread1 = threading.Thread(target=print_time, args=("Thread-1", 2))
thread2 = threading.Thread(target=print_time, args=("Thread-2", 4))
print('thread1.daemon:', thread1.daemon)
print('thread2.daemon:', thread2.daemon)
thread1.start()
thread2.start()
print('主程序结束')
输出结果如下：
thread1.daemon: False
thread2.daemon: False
主程序结束
Thread-1: Sat Aug 24 20:58:18 2024
Thread-2: Sat Aug 24 20:58:20 2024
Thread-1: Sat Aug 24 20:58:20 2024
Thread-1: Sat Aug 24 20:58:22 2024
Thread-2: Sat Aug 24 20:58:24 2024
Thread-1: Sat Aug 24 20:58:24 2024
Thread-1: Sat Aug 24 20:58:26 2024
Thread-2: Sat Aug 24 20:58:28 2024
...
注：当主线程结束时，非守护线程还会继续运行。
我们把 thread1、thread2 都改成守护线程，修改代码如下：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import threading
import time
def print_time( name, delay):
while True:
time.sleep(delay)
print ("%s: %s" % ( name, time.ctime(time.time()) ))
thread1 = threading.Thread(target=print_time, args=("Thread-1", 2))
thread2 = threading.Thread(target=print_time, args=("Thread-2", 4))
thread1.daemon = True
thread2.daemon = True
print('thread1.daemon:', thread1.daemon)
print('thread2.daemon:', thread2.daemon)
thread1.start()
thread2.start()
print('主程序结束')
输出结果如下：
thread1.daemon: True
thread2.daemon: True
主程序结束
注：当主线程结束时，守护线程自动退出了。
5. 线程优先级队列（Queue）
Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括 FIFO（先入先出）队列 Queue，LIFO（后入先出）队列 LifoQueue，和优先级队列 PriorityQueue。
这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
Queue 模块中的常用方法：
(1) qsize()：返回队列的大小；
(2) empty()：如果队列为空，返回 True，反之 False；
(3) full()：如果队列满了，返回 True，反之 False；
(4) get([block[, timeout]])：获取队列，timeout 等待时间；
(5) get_nowait()：相当于 get(False)；
(6) put(item)：写入队列；
(7) put_nowait(item)：相当于 put(item, False)；
(8) task_done()：在完成一项工作之后，Queue.task_done() 函数向任务已经完成的队列发送一个信号；
(9) join()：实际上意味着等到队列为空，再执行别的操作；
示例：
#!/usr/bin/python3
# -*- coding: UTF-8 -*-
import queue
import threading
import time
class TestThread(threading.Thread):
def __init__(self, name, delay, q):
super().__init__()
self.name = name
self.delay = delay
self.q = q
def run(self):
print_time(self.name, self.delay, self.q)
print("%s 结束" % self.name)
def print_time( name, delay, q):
while q.qsize() > 0:
i = q.get()
time.sleep(delay)
print ("%s: %s" % ( name, time.ctime(time.time()) ))
q.task_done() # 任务处理完成，通知队列
start = time.time()
# 创建 Queue 任务队列
q = queue.Queue()
for i in range(6):
q.put(i)
print('Queue 队列: ', q.qsize(), '任务')
thread1 = TestThread("Thread-1", 2, q)
thread2 = TestThread("Thread-2", 4, q)
thread1.start()
thread2.start()
q.join()
end = time.time()
print('主程序结束', int(end-start), '秒')
输出结果如下：
Queue 队列: 6 任务
Thread-1: Sat Aug 24 21:21:49 2024
Thread-1: Sat Aug 24 21:21:51 2024
Thread-2: Sat Aug 24 21:21:51 2024
Thread-1: Sat Aug 24 21:21:53 2024
Thread-1: Sat Aug 24 21:21:55 2024
Thread-2: Sat Aug 24 21:21:55 2024
Thread-1 结束
Thread-2 结束
主程序结束 8 秒
标签：24,10,Aug,Thread,Python,线程,time,print,多线程 From： https://www.cnblogs.com/tkuang/p/18384196