多线程管理方案

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;
}