Python 线程学习知识大全
一、Python 线程简介
线程是操作系统能够进行运算调度的最小单位，在 Python 中，threading模块提供了对线程的支持。使用线程可以实现并行和并发执行任务，从而提高程序的效率。
二、Python 线程不用 join()
以下是一个没有使用join()的示例代码：
import threading
import time
def print_numbers():
# 打印数字 1 到 5
for i in range(1, 6):
print(f"Number: {i}")
time.sleep(1)
t = threading.Thread(target=print_numbers)
t.start()
print("Main thread continues without waiting for the child thread.")
在这个例子中，创建了一个线程t来执行print_numbers函数，该函数会依次打印数字 1 到 5，每次打印间隔 1 秒。主线程启动子线程后，不会等待子线程执行完毕，直接继续执行打印语句。
三、Python 线程用 join()
使用join()可以让主线程等待子线程执行完毕后再继续执行。
import threading
import time
def print_numbers():
for i in range(1, 6):
print(f"Number: {i}")
time.sleep(1)
t = threading.Thread(target=print_numbers)
t.start()
t.join()
print("Main thread waits for the child thread to finish.")
这里主线程在启动子线程后，调用t.join()，这会使主线程暂停，直到子线程执行完毕。
四、Python有输入参数的线程
可以向线程函数传递参数。
import threading
def print_name(name):
print(f"Hello, {name}!")
t = threading.Thread(target=print_name, args=("Alice",))
t.start()
在这个例子中，创建了一个线程来执行print_name函数，并传递参数"Alice"。
五、Python多线程
可以同时运行多个线程执行不同的任务。
import threading
import time
def task1():
for i in range(5):
print("Task 1:", i)
time.sleep(1)
def task2():
for i in range(5):
print("Task 2:", i)
time.sleep(1.5)
t1 = threading.Thread(target=task1)
t2 = threading.Thread(target=task2)
t1.start()
t2.start()
这里同时启动两个线程分别执行不同的任务。
六、Python守护线程
守护线程在主线程退出时会自动退出。
import threading
import time
def background_task():
while True:
print("Background task is running...")
time.sleep(2)
t = threading.Thread(target=background_task)
t.daemon = True
t.start()
print("Main thread is exiting.")
在这个例子中，创建了一个守护线程t，如果不是守护线程，即使主线程退出，后台任务仍会继续运行，而设置为守护线程后，当主线程退出时，守护线程也会自动退出。
七、Python使用锁来实现线程同步
使用锁来实现线程同步，防止多个线程同时访问共享资源导致数据不一致。
import threading
counter = 0
lock = threading.Lock()
def increment():
global counter
for _ in range(10000):
with lock:
counter += 1
t1 = threading.Thread(target=increment)
t2 = threading.Thread(target=increment)
t1.start()
t2.start()
t1.join()
t2.join()
print(f"Final counter value: {counter}")
两个线程同时对全局变量counter进行递增操作，使用锁确保在一个线程操作counter时，其他线程不能同时进行操作。
八、Python使用队列实现线程间通信
使用队列实现线程间通信。
import threading
import queue
def producer(q):
for i in range(5):
q.put(i)
print(f"Produced: {i}")
def consumer(q):
while True:
item = q.get()
if item is None:
break
print(f"Consumed: {item}")
q = queue.Queue()
t1 = threading.Thread(target=producer, args=(q,))
t2 = threading.Thread(target=consumer, args=(q,))
t1.start()
t2.start()
t1.join()
q.put(None)
t2.join()
producer线程向队列中放入数据，consumer线程从队列中取出数据进行处理。
九、Python使用线程池来管理多个线程的执行
使用线程池来管理多个线程的执行。
import concurrent.futures
def square_number(n):
return n * n
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
numbers = [2, 3, 4, 5]
results = executor.map(square_number, numbers)
for result in results:
print(result)
创建一个线程池，将任务分配给线程池中的线程执行。
十、Python 使用事件来实现线程间的同步
使用事件来实现线程间的同步。
import threading
event = threading.Event()
def wait_for_event():
print("Waiting for event...")
event.wait()
print("Event received!")
def set_event():
print("Setting event...")
event.set()
t1 = threading.Thread(target=wait_for_event)
t2 = threading.Thread(target=set_event)
t1.start()
t2.start()
一个线程等待事件，另一个线程设置事件，从而实现线程间的同步。
十一、比较单线程和多线程在 I/O 任务上的速度
比较单线程和多线程在 I/O 任务上的速度。
import time
import threading
def io_task(delay):
time.sleep(delay)
# 单线程执行
start_time = time.time()
io_task(2)
io_task(2)
print(f"Single-threaded time: {time.time() - start_time} seconds")
# 多线程执行
start_time = time.time()
t1 = threading.Thread(target=io_task, args=(2,))
t2 = threading.Thread(target=io_task, args=(2,))
t1.start()
t2.start()
t1.join()
t2.join()
print(f"Multi-threaded time: {time.time() - start_time} seconds")
可以观察到在 I/O 任务中，多线程可以提高执行效率，减少总执行时间。
十二、比较多线程和多进程在 CPU 密集型任务上的速度
比较多线程和多进程在 CPU 密集型任务上的速度。
import time
from multiprocessing import Process
import threading
def cpu_task(n):
result = 0
for _ in range(n):
result += 1
# 多线程执行
start_time = time.time()
t1 = threading.Thread(target=cpu_task, args=(100000000,))
t2 = threading.Thread(target=cpu_task, args=(100000000,))
t1.start()
t2.start()
t1.join()
t2.join()
print(f"Multi-threaded CPU task time: {time.time() - start_time} seconds")
# 多进程执行
start_time = time.time()
p1 = Process(target=cpu_task, args=(100000000,))
p2 = Process(target=cpu_task, args=(100000000,))
p1.start()
p2.start()
p1.join()
p2.join()
print(f"Multi-process CPU task time: {time.time() - start_time} seconds")
在 CPU 密集型任务中，多进程通常比多线程更有效，因为 Python 的全局解释器锁（GIL）限制了多线程在 CPU 密集型任务上的性能。
原文地址：https://blog.csdn.net/gzjimzhou/article/details/143490910
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！