C++面试需知——并发与多线程

并发与多线程 (C++11/14/17/20)


1. 基础概念

*问题类型:

  • 进程(Process)和线程(Thread)的区别?

    特性 进程 线程
    定义 资源分配的最小单位(独立程序实例) CPU调度的最小单位(进程内的执行流)
    资源占用 独立地址空间、文件描述符、全局变量 共享进程资源(堆、全局变量)
    创建开销 高(需复制或写时复制资源) 低(仅需分配栈和寄存器)
    隔离性 高(崩溃不影响其他进程) 低(线程崩溃可能导致整个进程终止)
    通信方式 管道、消息队列、共享内存、信号 直接读写共享内存(需同步)
    切换成本 高(需切换页表、刷新TLB) 低(仅切换寄存器、栈)

    关键比喻

    • 进程 = 独立工厂(拥有独立资源和生产线)
    • 线程 = 工厂内工人(共享工厂资源,协作完成任务)
  • 并发(Concurrency)和并行(Parallelism)的区别?

    概念 并发 并行
    核心目标 同时处理多任务(逻辑上) 同时执行多任务(物理上)
    依赖硬件 单核即可实现(时间片轮转) 需多核/多CPU
    实现方式 线程切换、异步I/O 多线程分派到不同核心
    关系 并发包含并行(并行是并发的子集) 并行是并发的最高效形式

    示例

    • 并发:单核CPU处理10个网络请求(交替执行)
    • 并行:8核CPU同时渲染8帧视频
  • 线程安全(Thread Safety)和数据竞争(Data Race)?

    问题 定义 解决方案
    线程安全 多线程访问时行为正确(如无数据污染) 同步机制(互斥锁、原子操作)
    数据竞争 多线程无同步访问共享数据且至少1次写 互斥锁(std::mutex)、原子变量(std::atomic

    数据竞争示例

    cpp 复制代码
    int counter = 0; // 共享变量  
    void unsafe_increment() {  
        counter++;  // 非原子操作 → 数据竞争  
    }  
    // 两个线程同时调用 unsafe_increment() 导致结果不可预测  

    修复方案

    cpp 复制代码
    std::mutex mtx;  
    void safe_increment() {  
        std::lock_guard<std::mutex> lock(mtx);  
        counter++;  
    }  
  • 死锁(Deadlock)的条件和避免策略?

    • 四个必要条件(缺一不可):

      1. 互斥:资源独占使用
      2. 请求保持:持有资源时请求新资源
      3. 不可剥夺:资源只能主动释放
      4. 循环等待:线程间形成等待环
    • 避免策略

      策略 实现方式
      加锁顺序 所有线程按固定顺序获取锁
      锁超时 try_lock_for() 超时放弃锁
      死锁检测 运行时监控锁依赖图(如数据库系统)
      资源分级 将资源分层,禁止跨层请求

    经典死锁场景

    cpp 复制代码
    // 线程1:lock(A); lock(B);  
    // 线程2:lock(B); lock(A);  // 可能死锁  
  • 活锁(Livelock)和饥饿(Starvation)?

    问题 原因 特点
    活锁 线程不断"让出资源"导致任务无法推进 类似死锁,但线程仍在运行(如反复重试)
    饥饿 低优先级线程长期得不到资源(CPU/锁) 部分线程有进展,个别线程被"饿死"

    活锁示例

    cpp 复制代码
    // 两人在走廊相遇,同时让路又再次阻塞对方  
    while (collision_detected) {  
        move_left();    // 对方也同时 move_left() → 仍碰撞  
        move_right();   // 对方也 move_right() → 无限循环  
    }  

    饥饿解决方案

    • 公平锁(std::mutex 无法保证 → 需用队列或 std::shared_mutex
    • 优先级调整(如 Linux 的 nice 值)

    关键总结

    • 进程:资源隔离的独立执行环境
    • 线程:轻量级执行流(共享内存,需同步)
    • 并发问题核心
      • 数据竞争 → 同步控制
      • 死锁/活锁 → 设计无锁结构或严格锁序
      • 饥饿 → 公平调度机制

2. C++11 线程库

*问题类型:

  • std::thread的创建、管理和推理?

    操作 方法 说明
    创建线程 std::thread t(func, args...) 启动线程执行函数 func
    移动线程 std::thread t2 = std::move(t1) 线程所有权转移(t1 不再管理线程)
    销毁线程 析构函数自动调用 若线程可联结(joinable)则 std::terminate

    生命周期规则

    • 线程对象销毁前必须调用 join()detach()

    • 错误示例

      cpp 复制代码
      {  
          std::thread t([]{ /*...*/ });  
      } // 析构时 t 仍 joinable → 程序崩溃  
  • join()detach()的区别?

    方法 行为 后续操作 使用场景
    join() 阻塞当前线程直到目标线程结束 线程资源可安全回收 需等待结果的任务
    detach() 分离线程(后台运行) 失去线程控制权 长时间运行的后台任务

    关键限制

    • detach() 后无法再操作线程(如强制终止)
    • 分离线程不能访问局部变量(可能已销毁)
  • 互斥量派std::mutex及其生类(std::recursive_mutex,std::timed_mutex等)?

    互斥量类型 特性 适用场景
    std::mutex 基本互斥锁(不可递归) 通用场景
    std::recursive_mutex 可递归加锁(同一线程多次加锁) 递归函数中的共享资源保护
    std::timed_mutex 支持超时加锁(try_lock_for/until 避免死锁的等待操作
    std::shared_mutex (C++17) 读写锁(共享读/独占写) 读多写少场景(如缓存)
  • std::lock_guardstd::unique_lock的作用和区别?

    特性 std::lock_guard std::unique_lock
    锁管理 RAII 自动加锁/解锁 同左 + 支持手动控制
    灵活性 低(构造即加锁) 高(延迟加锁/提前解锁)
    性能开销 低(无额外状态) 稍高(维护锁状态)
    适用场景 简单作用域保护 条件变量配合/需转移锁所有权

    示例对比

    cpp 复制代码
    // lock_guard  
    {  
     std::lock_guard<std::mutex> lock(mtx); // 立即加锁  
     // 临界区  
    } // 自动解锁  
    
    // unique_lock  
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);  
    lock.lock(); // 手动加锁  
    lock.unlock(); // 可提前解锁  
  • 条件变量std::condition_variable的作用和使用场景(生产者-消费者模型)?

    • 作用:线程间同步(阻塞等待条件成立)

    • 经典场景:生产者-消费者模型

      cpp 复制代码
      // 生产者  
      {  
          std::lock_guard<std::mutex> lock(mtx);  
          queue.push(data);  
          cv.notify_one(); // 唤醒一个消费者  
      }  
      // 消费者  
      std::unique_lock<std::mutex> lock(mtx);  
      cv.wait(lock, [&]{ return !queue.empty(); }); // 防止虚假唤醒  
      auto data = queue.front(); queue.pop();  
  • 原子操作std::atomic的作用?

    • 作用:无锁线程安全操作(硬件级原子指令)

    • 优势

      • 免锁高性能(如计数器)
      • 避免数据竞争(counter++ 安全)
    • 示例

      cpp 复制代码
      std::atomic<int> counter(0);  
      void safe_increment() { counter.fetch_add(1, std::memory_order_relaxed); }  
  • std::futurestd::promise的作用?

    组件 作用 关系
    std::promise 存储异步结果(生产者) 与 future 共享状态
    std::future 获取异步结果(消费者) 从 promise 或 async 获取结果

    工作流程

    cpp 复制代码
    std::promise<int> p;  
    std::future<int> f = p.get_future();  
    
    // 生产者线程  
    std::thread t([&p]{ p.set_value(42); });  
    
    // 消费者  
    int result = f.get(); // 阻塞等待结果  
    t.join();  
  • std::async的作用和使用?

    • 作用 :异步执行函数并返回 future

    • 启动策略

      • std::launch::async:强制新线程执行
      • std::launch::deferred:延迟执行(调用 get() 时运行)
    • 示例

      cpp 复制代码
      auto future = std::async(std::launch::async, []{  
          return compute_heavy_task();  
      });  
      auto result = future.get(); // 阻塞获取结果  
  • 线程池的实现原理?

    • 核心组件

      1. 任务队列 :存储待执行函数(std::function<void()>
      2. 工作线程组:固定数量线程循环取任务执行
      3. 同步机制:互斥锁 + 条件变量
    • 工作流程

      cpp 复制代码
      while (running) {  
          std::unique_lock<std::mutex> lock(queue_mutex);  
          cv.wait(lock, [&]{ return !tasks.empty() || !running; });  
          if (!running) break;  
          auto task = std::move(tasks.front());  
          tasks.pop();  
          lock.unlock();  
          task(); // 执行任务  
      }  
    • 优势

      • 避免线程创建/销毁开销
      • 控制并发度(防止资源耗尽)
相关推荐
黑色火種2 小时前
CCF CSP第一轮认证一本通
c++·csp·ccf·信奥赛·noi
不二青衣2 小时前
牛客网50题
数据结构·c++·算法
武当豆豆7 小时前
C++编程学习阶段性总结
开发语言·c++
A7bert7779 小时前
【YOLOv8-obb部署至RK3588】模型训练→转换RKNN→开发板部署
linux·c++·人工智能·python·yolo
zyx没烦恼10 小时前
五种IO模型
开发语言·c++
EutoCool11 小时前
Qt窗口:菜单栏
开发语言·c++·嵌入式硬件·qt·前端框架
圆头猫爹13 小时前
第34次CCF-CSP认证第4题,货物调度
c++·算法·动态规划
十五年专注C++开发13 小时前
hiredis: 一个轻量级、高性能的 C 语言 Redis 客户端库
开发语言·数据库·c++·redis·缓存
_一条咸鱼_13 小时前
Android Runtime直接内存管理原理深度剖析(73)
android·面试·android jetpack
hi0_614 小时前
03 数组 VS 链表
java·数据结构·c++·笔记·算法·链表