面试题：C++ 多线程与多进程混合编程中的性能优化与死锁预防

性能瓶颈分析

线程上下文切换开销：多线程环境下，线程数量过多会导致频繁的上下文切换，消耗 CPU 时间。例如在一个高并发的网络服务器项目中，大量的客户端连接处理线程如果不加控制，会造成上下文切换开销显著增加。
进程间通信开销：多进程间通信（如管道、共享内存、Socket 等）存在一定的性能损耗。以共享内存为例，虽然数据传输速度快，但同步和互斥操作（如信号量）会带来额外开销。在分布式数据库项目中，不同进程间的数据交互频繁，通信开销可能成为瓶颈。
资源竞争：线程或进程同时访问共享资源（如文件、数据库连接等）时，可能会因为锁机制导致性能下降。在一个文件处理项目中，多个线程或进程同时读写文件，频繁的加锁解锁会降低整体性能。

死锁风险分析

循环等待资源：线程或进程之间形成资源请求的环形链，每个都在等待下一个持有的资源。例如，在一个图形渲染项目中，线程 A 持有资源 R1 并请求 R2，线程 B 持有 R2 并请求 R1，就会形成死锁。
资源分配不当：不合理的资源分配策略，如一次性分配大量资源给某个线程或进程，可能导致其他线程或进程因资源不足而长时间等待，增加死锁风险。

优化策略 - 代码层面

线程池设计：

线程数量控制：根据系统 CPU 核心数和任务类型动态调整线程池大小。例如对于 CPU 密集型任务，线程数可以设置为 CPU 核心数；对于 I/O 密集型任务，可以适当增加线程数。
任务队列管理：使用阻塞队列存储待执行任务，线程从队列中获取任务执行。可以采用 std::queue 结合 std::mutex 和 std::condition_variable 实现。

class ThreadPool {
public:
    ThreadPool(size_t numThreads) {
        for (size_t i = 0; i < numThreads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(this->queueMutex);
                        this->condition.wait(lock, [this] {
                            return this->stop ||!this->tasks.empty();
                        });
                        if (this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
        using return_type = typename std::result_of<F(Args...)>::type;
        auto task = std::make_shared<std::packaged_task<return_type()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        std::future<return_type> res = task->get_future();
        {
            std::unique_lock<std::mutex> lock(queueMutex);
            if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
            tasks.emplace([task]() { (*task)(); });
        }
        condition.notify_one();
        return res;
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queueMutex;
    std::condition_variable condition;
    bool stop = false;
};

进程池设计：
- 进程创建与管理：使用 fork() 或类似函数创建进程，并通过管道、共享内存等方式与进程池管理进程通信。例如在一个 web 服务器项目中，进程池中的每个进程负责处理特定数量的客户端请求。
- 负载均衡：可以采用轮询、加权轮询等算法将任务分配给进程池中的进程。
优化资源访问：
- 减少锁粒度：将大的共享资源分割成小的部分，每个部分单独加锁。例如在一个数据库缓存项目中，对不同的数据块分别加锁，而不是对整个缓存加锁。
- 锁优化：选择合适的锁类型，如读写锁（std::shared_mutex）用于读多写少的场景。

优化策略 - 架构层面

分层架构：将项目功能划分为不同层次，如数据访问层、业务逻辑层、表示层等。不同层次可以使用不同的线程或进程模型。例如数据访问层可以使用进程池来处理数据库操作，业务逻辑层使用线程池处理计算任务。
分布式架构：将系统拆分为多个分布式节点，每个节点可以是一个进程或一组进程。通过分布式缓存、负载均衡器等组件提高系统性能和可扩展性。在大型电商系统中，商品库存管理、订单处理等模块可以分布在不同节点上。

死锁预防措施 - 代码层面

资源分配图算法：
- 资源分配图算法原理：通过记录进程对资源的请求和分配关系，形成资源分配图。定期检查图中是否存在环，若存在环则可能存在死锁。
- 代码实现思路：可以使用邻接表或邻接矩阵表示资源分配图，利用深度优先搜索（DFS）或并查集算法检测环。
破坏死锁条件：
- 破坏互斥条件：尽量避免使用独占资源，若必须使用，可以考虑使用共享资源替代。
- 破坏占有并等待条件：要求进程一次性申请所有需要的资源，避免在持有部分资源的情况下再请求其他资源。
- 破坏不可剥夺条件：当一个进程请求的资源被其他进程占用时，允许操作系统剥夺占用进程的资源分配给请求进程。
- 破坏循环等待条件：对资源进行排序，要求进程按照一定顺序请求资源，避免形成环形请求链。

死锁预防措施 - 架构层面

资源监控与管理：设计一个资源监控模块，实时监控资源的使用情况和分配状态。当发现资源使用异常或可能导致死锁的情况时，及时进行干预，如调整资源分配策略。
系统设计冗余：在架构设计中引入一定的冗余资源，当某个资源出现死锁或故障时，可以使用冗余资源继续运行，避免系统崩溃。例如在网络系统中，设置多条备用链路。

星途面试题库

面试题：C++ 多线程与多进程混合编程中的性能优化与死锁预防

知识考点

面试题答案

性能瓶颈分析

死锁风险分析

优化策略 - 代码层面

优化策略 - 架构层面

死锁预防措施 - 代码层面

死锁预防措施 - 架构层面