1. 线程创建与池化
限制线程数量:
假设你正在开发一个网络服务器,它可以同时处理数千个客户端连接。如果为每个连接创建一个新线程,很快就会耗尽系统资源,因为每个线程都需要内存和其他资源,并且上下文切换会严重降低性能。相反,你可以根据服务器的核心数量来限制工作线程的数量,比如,如果服务器有 4 个核心,你可能会创建 8 个工作线程(假设每个核心处理两个线程效率最高)。
使用线程池:
考虑一个图像处理应用,用户上传图片批量进行滤镜处理。处理每张图片是一个独立的任务,但是如果每个任务都创建一个新线程,随着用户上传的图片增多,应用的响应时间会显著增加。使用线程池,你可以创建一个固定数量的线程(例如根据处理器的核心数),并且每个线程可以从任务队列中取出任务执行。当一个线程完成任务后,它会返回线程池并准备处理下一个任务。这样就避免了频繁创建和销毁线程的开销。
from concurrent.futures import ThreadPoolExecutor, as_completed
def process_image(image):
"""处理一张图片的函数"""
print(f"处理图片: {image}")
# 模拟图片处理
return f"{image} 已处理"
# 创建线程池,最大线程数为4
with ThreadPoolExecutor(max_workers=4) as executor:
# 提交任务到线程池
tasks = [executor.submit(process_image, f"图片{i}") for i in range(10)]
# 等待所有任务完成,并获取结果
for future in as_completed(tasks):
print(future.result())
2. 线程同步
避免死锁:
假设有两个线程,分别需要访问资源 A 和资源 B。如果线程 1 锁定了资源 A 并尝试锁定资源 B,而线程 2 已经锁定了资源 B 并尝试锁定资源 A,这就会导致死锁。为了避免这种情况,可以设计一个固定的资源获取顺序(例如总是先锁定资源 A,然后锁定资源 B),或者使用 std::lock 来同时锁定两个资源,避免死锁。
减少锁的竞争:
设想一个在线票务系统,其中包含一个共享的座位地图。如果为整个座位地图使用单一的锁,那么每次只有一个线程可以检查或预订座位,这会导致严重的瓶颈。改进的方法是将座位地图划分为几个部分,每部分有自己的锁。这样,如果两个线程想预订不同部分的座位,它们可以并行执行,减少了锁的竞争。
#include <iostream>
#include <thread>
#include <mutex>
std::mutex mutexA;
std::mutex mutexB;
void thread1_function() {
std::lock(mutexA, mutexB); // 同时锁定两个互斥量,避免死锁
std::lock_guard<std::mutex> lockA(mutexA, std::adopt_lock);
std::lock_guard<std::mutex> lockB(mutexB, std::adopt_lock);
// 执行线程1的任务...
std::cout << "线程1执行完成" << std::endl;
}
void thread2_function() {
std::lock(mutexA, mutexB); // 同样的方式,避免死锁
std::lock_guard<std::mutex> lockA(mutexA, std::adopt_lock);
std::lock_guard<std::mutex> lockB(mutexB, std::adopt_lock);
// 执行线程2的任务...
std::cout << "线程2执行完成" << std::endl;
}
int main() {
std::thread thread1(thread1_function);
std::thread thread2(thread2_function);
thread1.join();
thread2.join();
return 0;
}
3. 线程通信
使用线程安全的队列:
考虑一个生产者-消费者场景,生产者生成数据,消费者处理数据。生产者将数据放入一个线程安全的队列中,如果队列为空,消费者线程会阻塞,直到队列中有数据可用。当生产者放入数据时,阻塞的消费者线程会被唤醒。这种方式避免了忙等待,提高了效率。
使用条件变量:
假设有一个任务,需要在线程 A 中完成一些工作,然后线程 B 才能继续处理。线程 A 在完成其工作后,可以通过条件变量通知线程 B。线程 B 在等待条件变量时会阻塞,直到线程 A 发送通知。这样就能确保任务以正确的顺序执行。
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
std::mutex mutex;
std::condition_variable cond_var;
bool ready = false; // 用于通知的条件
void print_id(int id) {
std::unique_lock<std::mutex> lock(mutex);
while (!ready) cond_var.wait(lock); // 等待主线程发出通知
// 打印线程的ID
std::cout << "线程 " << id << std::endl;
}
void go() {
std::unique_lock<std::mutex> lock(mutex);
ready = true; // 设置条件为true
cond_var.notify_all(); // 通知所有等待线程
}
int main() {
std::thread threads[10];
// 创建线程
for (int i = 0; i < 10; ++i)
threads[i] = std::thread(print_id, i);
std::cout << "10个线程准备好了,准备开始运行..." << std::endl;
go(); // 通知所有线程开始运行
// 等待所有线程完成
for (auto& th : threads) th.join();
return 0;
}