C++ 并发学习笔记（1）：基础概念

1. 并发和并行的区别

• 并发（Concurrency）
  并发是指程序中可以同时处理多个任务的能力，但这些任务不一定同时运行。例如，单核 CPU 可以通过快速切换任务来实现并发。
  举例：

  • 一个服务端同时处理多个客户端的请求。
  • 多个线程访问同一个资源，按照一定规则交替执行。

• 并行（Parallelism）
  并行是指程序在物理上同时运行多个任务，通常需要多核 CPU 或多个处理器。
  举例：

  • 一个图像处理程序分块处理图片，每块由一个核心独立计算。
  • GPU 中多个核心同时计算矩阵运算。

---

2. 线程（Thread）和进程（Process）

• 进程（Process）
  进程是操作系统分配资源（如内存、文件句柄）的基本单位，每个进程拥有独立的地址空间。多个进程之间可以通过进程间通信（IPC）进行数据传递，但通常开销较大。

• 线程（Thread）
  线程是进程中的基本执行单位，每个进程可以包含多个线程，这些线程共享进程的地址空间。线程之间通信方便，但也更容易引发竞争问题。
  C++ 示例：

  #include <iostream>
  #include <thread>
  
  void hello() {
      std::cout << "Hello from thread!" << std::endl;
  }
  
  int main() {
      std::thread t(hello);  // 创建线程
      t.join();              // 等待线程完成
      return 0;
  }
  
  

3. 数据竞争（Race Condition）

当多个线程同时访问同一个共享资源并尝试修改其内容，且访问顺序不受控制时，会发生数据竞争，可能导致程序行为不确定。

示例（错误代码）：

#include <iostream>
#include <thread>

int counter = 0;

void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;  // 存在数据竞争
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;
    return 0;
}

输出： 因为 counter 没有正确保护，可能输出 2000，也可能小于 2000。

线程执行的时间线

假设 counter 的初始值是 0，t1 和 t2 都执行 ++counter，它们的执行顺序可能如下：

时间	线程 1 (t1)	线程 2 (t2)	counter
T1	读取 counter = 0
T2		读取 counter = 0
T3	计算 counter + 1 = 1
T4		计算 counter + 1 = 1
T5	写回 counter = 1		1
T6		写回 counter = 1	1

结果： 两个线程都把 counter 从 0 增加到 1，但正确的结果应该是 2。这种现象就是数据竞争。

锁的概念

锁（Lock）是多线程编程中用于协调对共享资源的访问的一种机制。它通过强制线程在访问共享资源时进行排他操作，从而防止数据竞争（Race Condition）**。

在没有锁的情况下，多个线程可以同时访问共享资源，这可能导致数据的不一致性。而锁通过控制线程的访问顺序，确保同一时刻只有一个线程可以操作共享资源。

锁的工作机制

1. 一个线程在访问共享资源之前需要获取锁。

   • 如果锁是空闲的，该线程可以成功获取锁并继续运行。
   • 如果锁已被其他线程占用，当前线程会进入阻塞状态，直到锁被释放。

2. 线程完成共享资源的操作后，必须释放锁，以便其他线程可以获取该锁并执行。

锁的分类

1. 互斥锁（Mutex, Mutual Exclusion Lock）：
   确保同一时刻只有一个线程可以访问共享资源。

   • C++ 提供了 std::mutex。
   • 适用于保护临界区。

2. 读写锁（Read-Write Lock）：
   允许多个线程同时读取资源，但写操作是排他性的。

   • C++20 提供了 std::shared_mutex。

3. 递归锁（Recursive Lock）：
   允许同一个线程多次获取同一把锁，而不会产生死锁。

   • C++ 提供了 std::recursive_mutex。

4. 自旋锁（Spin Lock）：
   如果锁被占用，线程不会进入阻塞状态，而是持续尝试获取锁。

   • 适用于短时间锁定。

解决数据竞争方法：

为了解决这个问题，需要引入同步机制来确保 counter 的更新是线程安全的。

1.1. 使用互斥锁（std::mutex）

通过互斥锁，保证每次只有一个线程可以修改 counter。

#include <iostream>
#include <thread>
#include <mutex>

int counter = 0;          // 共享资源
std::mutex mtx;           // 互斥锁

void increment() {
    for (int i = 0; i < 1000; ++i) {
        std::lock_guard<std::mutex> lock(mtx);  // 加锁，确保线程安全
        ++counter;
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;  // 正确结果为 2000
    return 0;
}

1.2. 使用 std::lock_guard 自动管理锁

• std::lock_guard<std::mutex> 是一个 RAII（资源获取即初始化）类。
• 它会在构造时自动加锁，在析构时自动释放锁。

优点：不需要手动调用 lock() 和 unlock()，即使中途异常也会释放锁，避免死锁。

1.3. 手动锁定与解锁

你也可以手动调用 lock() 和 unlock() 方法，但要小心防止遗漏解锁：

mtx.lock();   // 手动加锁
++counter;    // 临界区
mtx.unlock(); // 手动解锁

2. 使用原子操作（std::atomic）

原子操作可以确保 ++counter 是一个不可分割的操作，避免数据竞争。

#include <iostream>
#include <thread>
#include <atomic>

std::atomic<int> counter(0);  // 原子变量

void increment() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;  // 原子操作，线程安全
    }
}

int main() {
    std::thread t1(increment);
    std::thread t2(increment);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;  // 正确结果为 2000
    return 0;
}