文章	分类	评论
32	8	0

站点介绍

终于比较舒服了

C++面向对象---进阶（多线程）

首页 / 正文

[TOC]

#### 一、 多线程

线程是程序中的轻量级执行单元，允许程序同时执行多个任务。

多线程是多任务处理的一种特殊形式，多任务处理允许让电脑同时运行两个或两个以上的程序。

一般情况下，两种类型的多任务处理：**基于进程和基于线程**。

- 基于进程的多任务处理是程序的并发执行。
- 基于线程的多任务处理是同一程序的片段的并发执行。

![](http://120.26.238.80/usr/uploads/2025/11/2342848803.png)

C++ 多线程编程涉及在一个程序中创建和管理多个并发执行的线程。

在 C++11 标准及其之后，通过 `<thread>` 标准库使得多线程编程变得更加简单和安全。

##### 概念说明

**线程 (Thread)**

- 线程是程序执行中的单一顺序控制流，多个线程可以在同一个进程中独立运行。
- 线程共享进程的地址空间、文件描述符、堆和全局变量等资源，但每个线程有自己的栈、寄存器和程序计数器。

**并发 (Concurrency) 与并行 (Parallelism)**

- **并发**：多个任务在时间片段内交替执行，表现出同时进行的效果。
- **并行**：多个任务在多个处理器或处理器核上同时执行。

多线程支持，核心组件包括：

- **`std::thread`**：用于创建和管理线程。
- **`std::mutex`**：用于线程之间的互斥，防止多个线程同时访问共享资源。
- **`std::lock_guard`** 和 **`std::unique_lock`**：用于管理锁的获取和释放。
- **`std::condition_variable`**：用于线程间的条件变量，协调线程间的等待和通知。
- **`std::future`** 和 **`std::promise`**：用于实现线程间的值传递和任务同步。

##### 创建线程

```c++
#include<thread>
std::thread thread_object(callable, args...);
```

- **`callable`**：可调用对象，可以是函数指针、函数对象、Lambda 表达式等。
- **`args...`**：传递给 `callable` 的参数列表。

```c++
#include <iostream>
#include <thread>

void printMessage(int count) {
  for (int i = 0; i < count; ++i) {
    std::cout << "Hello from thread (function pointer)!**\n**";
  }
}

int main() {
  std::thread t1(printMessage, 5); // 创建线程，传递函数指针和参数
  t1.join(); // 等待线程完成
  return 0;
}
```

##### 使用函数对象

```c++
#include <iostream>
#include <thread>

class PrintTask {
public:
  void operator()(int count) const {
    for (int i = 0; i < count; ++i) {
      std::cout << "Hello from thread (function object)!**\n**";
    }
  }
};

int main() {
  std::thread t2(PrintTask(), 5); // 创建线程，传递函数对象和参数
  t2.join(); // 等待线程完成
  return 0;
}
```

##### 使用 Lambda 表达式

```c++
#include <iostream>
#include <thread>

int main() {
  std::thread t3([](int count) {
    for (int i = 0; i < count; ++i) {
      std::cout << "Hello from thread (lambda)!**\n**";
    }
  }, 5); // 创建线程，传递 Lambda 表达式和参数
  t3.join(); // 等待线程完成
  return 0;
}
```

##### 线程管理

**join()**

join() 用于等待线程完成执行。如果不调用 join() 或 detach() 而直接销毁线程对象，会导致程序崩溃。

**detach()**

detach() 将线程与主线程分离，线程在后台独立运行，主线程不再等待它。

```
t.detach();
```

##### 线程的传参

**值传递**

参数可以通过值传递给线程：

```
std::thread t(func, arg1, arg2);
```

**引用传递**

如果需要传递引用参数，需要使用 std::ref：

```c++
#include <iostream>
#include <thread>

void increment(int& x) {
  ++x;
}

int main() {
  int num = 0;
  std::thread t(increment, std::ref(num)); // 使用 std::ref 传递引用
  t.join();
  std::cout << "Value after increment: " << num << std::endl;
  return 0;
}
```

##### 线程同步与互斥

**1. 互斥量（Mutex）**

互斥量是一种同步原语，用于防止多个线程同时访问共享资源。当一个线程需要访问共享资源时，它首先需要锁定（lock）互斥量。如果互斥量已经被其他线程锁定，那么请求锁定的线程将被阻塞，直到互斥量被解锁（unlock）。

**std::mutex**：用于保护共享资源，防止数据竞争。

```c++
std::mutex mtx;
mtx.lock();   // 锁定互斥锁
// 访问共享资源
mtx.unlock(); // 释放互斥锁
```

**std::lock_guard** 和 **std::unique_lock**：自动管理锁的获取和释放。

```
std::lock_guard<std::mutex> lock(mtx); // 自动锁定和解锁
// 访问共享资源
```

**2. 锁（Locks）**

C++提供了多种锁类型，用于简化互斥量的使用和管理。

常见的锁类型包括：

- std::lock_guard：作用域锁，当构造时自动锁定互斥量，当析构时自动解锁。
- std::unique_lock：与std::lock_guard类似，但提供了更多的灵活性，例如可以转移所有权和手动解锁。

```c++
#include <mutex>

std::mutex mtx;

void safeFunctionWithLockGuard() {
  std::lock_guard<std::mutex> lk(mtx);
  // 访问或修改共享资源
}

void safeFunctionWithUniqueLock() {
  std::unique_lock<std::mutex> ul(mtx);
  // 访问或修改共享资源
  // ul.unlock(); // 可选：手动解锁
  // ...
}
```

**3. 条件变量（Condition Variable）**

条件变量用于线程间的协调，允许一个或多个线程等待某个条件的发生。它通常与互斥量一起使用，以实现线程间的同步。

**std::condition_variable**用于实现线程间的等待和通知机制。

```c++
std::condition_variable cv;
std::mutex mtx;
bool ready = false;

std::unique_lock<std::mutex> lock(mtx);
cv.wait(lock, []{ return ready; }); // 等待条件满足
// 条件满足后执行
```

**4. 原子操作（Atomic Operations）**

原子操作确保对共享数据的访问是不可分割的，即在多线程环境下，原子操作要么完全执行，要么完全不执行，不会出现中间状态。

原子操作的使用示例：

```c++
#include <atomic>
#include <thread>

std::atomic<int> count(0);

void increment() {
  count.fetch_add(1, std::memory_order_relaxed);
}

int main() {
  std::thread t1(increment);
  std::thread t2(increment);
  t1.join();
  t2.join();
  return count; // 应返回2
}
```

**5. 线程局部存储（Thread Local Storage, TLS）**

线程局部存储允许每个线程拥有自己的数据副本。这可以通过thread_local关键字实现，避免了对共享资源的争用。

```c++
#include <iostream>
#include <thread>

thread_local int threadData = 0;

void threadFunction() {
  threadData = 42; // 每个线程都有自己的threadData副本
  std::cout << "Thread data: " << threadData << std::endl;
}

int main() {
  std::thread t1(threadFunction);
  std::thread t2(threadFunction);
  t1.join();
  t2.join();
  return 0;
}
```

**6. 死锁（Deadlock）和避免策略**

死锁发生在多个线程互相等待对方释放资源，但没有一个线程能够继续执行。避免死锁的策略包括：

- 总是以相同的顺序请求资源。
- 使用超时来尝试获取资源。
- 使用死锁检测算法。

##### 线程间通信

std::future 和 std::promise：实现线程间的值传递。

```c++
std::promise<int> p;
std::future<int> f = p.get_future();

std::thread t([&p] {
  p.set_value(10); // 设置值，触发 future
});

int result = f.get(); // 获取值
```

**消息队列（基于 std::queue 和 std::mutex）实现简单的线程间通信。**

C++17 引入了并行算法库（`<algorithm>`），其中部分算法支持并行执行，可以利用多核 CPU 提高性能。

```c++
#include <algorithm>
#include <vector>
#include <execution>

std::vector<int> vec = {1, 2, 3, 4, 5};
std::for_each(std::execution::par, vec.begin(), vec.end(), [](int &n) {
  n *= 2;
});
```

#### 二、C++ 信号处理

Ctrl+C 产生中断。

##### signal() 函数

**signal** 函数，用来捕获突发事件。

```c++
/*
void (*signal (int sig, void (*func)(int)))(int); 
signal(registered signal, signal handler)
*/
    
    
    
#include <iostream>
#include <csignal>
#include <unistd.h>
 
using namespace std;
 
void signalHandler( int signum )
{
    cout << "Interrupt signal (" << signum << ") received.\n";
 
    // 清理并关闭
    // 终止程序  
 
   exit(signum);  
 
}
 
int main ()
{
    // 注册信号 SIGINT 和信号处理程序
    signal(SIGINT, signalHandler);  
 
    while(1){
       cout << "Going to sleep...." << endl;
       sleep(1);
    }
 
    return 0;
}
```

##### raise() 函数

函数 **raise()** 生成信号，该函数带有一个整数信号编号作为参数

```c++
#include <iostream>
#include <csignal>
#include <unistd.h>
 
using namespace std;
 
void signalHandler( int signum )
{
    cout << "Interrupt signal (" << signum << ") received.\n";
 
    // 清理并关闭
    // 终止程序 
 
   exit(signum);  
 
}
 
int main ()
{
    int i = 0;
    // 注册信号 SIGINT 和信号处理程序
    signal(SIGINT, signalHandler);  
 
    while(++i){
       cout << "Going to sleep...." << endl;
       if( i == 3 ){
          raise( SIGINT);
       }
       sleep(1);
    }
 
    return 0;
}
```

版权所属: 别茬

本文链接: https://www.sybs18.cn/archives/57.html

协议授权: 《署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)》

日历

2025年12月

标签云

友情链接

陶小桃blog 友人C 冷文学习者

日	一	二	三	四	五	六
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31

别茬

站点介绍

C++面向对象---进阶（多线程）

评论(0)

热门文章

最新评论

日历

标签云

友情链接

文章目录

日	一	二	三	四	五	六
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31

日	一	二	三	四	五	六
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31

日	一	二	三	四	五	六
	1	2	3	4	5	6
7	8	9	10	11	12	13
14	15	16	17	18	19	20
21	22	23	24	25	26	27
28	29	30	31