C++并发编程之线程中断异常的捕捉与信息显示

捕鲸叉2025-01-21 12:30

在多线程编程中，线程任务在中止时捕捉异常并显示任务被中断的信息和现场（即线程的上下文），可以帮助开发人员更好地调试和分析问题。以下是一个设计和实现这种机制的示例，涵盖异常捕捉、中断信息的显示以及现场的保存与展示。

设计方法

  1. 定义自定义异常类：

    • 用于表示线程任务被中断的异常，包含中断原因和上下文信息。

  2. 在任务中捕捉异常：

    • 在线程任务中使用try-catch块捕捉异常，并在捕获到异常时显示中断信息和现场。

  3. 保存线程的上下文：

    • 使用操作系统提供的线程上下文信息（如寄存器、堆栈等），或通过编程语言提供的线程信息（如调用栈），保存任务中断时的现场。

  4. 显示中断信息和现场：

    • 将中断原因、线程ID、调用栈等信息输出到日志或控制台。

示例代码

以下是一个实现上述功能的示例代码，使用C++语言，并结合线程中断机制和异常捕捉机制：

cpp 复制代码 
#include <iostream>
#include <thread>
#include <stdexcept>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <csignal>
#include <execinfo.h> // 用于获取调用栈
#include <unistd.h>   // 用于获取线程ID

// 自定义异常类，表示线程中断
class ThreadInterruptedException : public std::exception {
public:
    explicit ThreadInterruptedException(const std::string& reason) : reason_(reason) {}

    const char* what() const noexcept override {
        return reason_.c_str();
    }

private:
    std::string reason_; // 中断原因
};

// 中断管理器类
class InterruptManager {
public:
    InterruptManager() : isInterrupted_(false) {}

    void interrupt(const std::string& reason) {
        std::lock_guard<std::mutex> lock(mutex_);
        isInterrupted_ = true;
        reason_ = reason;
        cv_.notify_all(); // 通知所有等待线程
    }

    bool isInterrupted() const {
        return isInterrupted_;
    }

    std::string getReason() const {
        return reason_;
    }

    void wait(std::unique_lock<std::mutex>& lock) {
        while (!isInterrupted_) {
            cv_.wait(lock);
        }
    }

private:
    std::atomic<bool> isInterrupted_; // 中断标志
    std::string reason_;              // 中断原因
    std::condition_variable cv_;      // 条件变量
    mutable std::mutex mutex_;        // 互斥锁
};

// 获取线程的调用栈
void getStackTrace(std::ostream& os) {
    void* callstack[128];
    int frames = backtrace(callstack, sizeof(callstack) / sizeof(callstack[0]));
    char** strs = backtrace_symbols(callstack, frames);

    os << "Stack Trace:\n";
    for (int i = 0; i < frames; ++i) {
        os << "  " << strs[i] << "\n";
    }

    free(strs);
}

// 线程任务函数
void threadTask(InterruptManager& manager) {
    std::unique_lock<std::mutex> lock(manager.mutex_);

    try {
        while (true) {
            // 检查中断标志
            if (manager.isInterrupted()) {
                throw ThreadInterruptedException(manager.getReason());
            }

            // 模拟阻塞操作
            std::cout << "Thread is running...\n";
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    } catch (const ThreadInterruptedException& e) {
        // 捕捉到线程中断异常
        std::cout << "Thread interrupted: " << e.what() << "\n";

        // 显示线程的上下文（调用栈）
        std::ostringstream stackTraceStream;
        getStackTrace(stackTraceStream);
        std::cout << stackTraceStream.str();
    }
}

// 中断线程的函数
void interruptThread(InterruptManager& manager, const std::string& reason) {
    manager.interrupt(reason);
}

int main() {
    // 创建中断管理器
    InterruptManager manager;

    // 创建线程并运行任务
    std::thread worker(threadTask, std::ref(manager));

    // 模拟中断（5秒后中断线程）
    std::this_thread::sleep_for(std::chrono::seconds(5));
    interruptThread(manager, "User requested interruption");

    // 等待线程结束
    worker.join();

    return 0;
}

代码说明

  1. 自定义异常类 ThreadInterruptedException：

    • 用于表示线程任务被中断的异常，包含中断原因。

  2. 中断管理器类 InterruptManager：

    • 提供中断标志、中断原因和条件变量的管理功能。
    • interrupt方法用于中断线程，并设置中断原因。

  3. 获取调用栈 getStackTrace：

    • 使用backtrace和backtrace_symbols函数获取当前线程的调用栈。

  4. 线程任务函数 threadTask：

    • 在线程任务中使用try-catch块捕捉ThreadInterruptedException。
    • 捕获异常后，显示中断信息和调用栈。

  5. 中断线程的函数 interruptThread：

    • 调用中断管理器的interrupt方法，中断线程并设置中断原因。

  6. 主函数 main：

    • 启动线程并运行任务。
    • 5秒后中断线程，并等待线程结束。

在Windows平台上实现多线程任务中断并捕捉异常的机制，可以使用Windows API（如CreateThread或C++11的std::thread）和结构化的异常处理（SEH）来实现。以下是一个适用于Windows的示例代码，展示如何捕捉线程中断异常并显示任务被中断的信息和现场。

Windows 版本代码

cpp 复制代码 
#include <windows.h>
#include <iostream>
#include <stdexcept>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <sstream>
#include <vector>

// 自定义异常类，表示线程中断
class ThreadInterruptedException : public std::exception {
public:
    explicit ThreadInterruptedException(const std::string& reason) : reason_(reason) {}

    const char* what() const noexcept override {
        return reason_.c_str();
    }

private:
    std::string reason_; // 中断原因
};

// 中断管理器类
class InterruptManager {
public:
    InterruptManager() : isInterrupted_(false) {}

    void interrupt(const std::string& reason) {
        std::lock_guard<std::mutex> lock(mutex_);
        isInterrupted_ = true;
        reason_ = reason;
        cv_.notify_all(); // 通知所有等待线程
    }

    bool isInterrupted() const {
        return isInterrupted_;
    }

    std::string getReason() const {
        return reason_;
    }

    void wait(std::unique_lock<std::mutex>& lock) {
        while (!isInterrupted_) {
            cv_.wait(lock);
        }
    }

private:
    std::atomic<bool> isInterrupted_; // 中断标志
    std::string reason_;              // 中断原因
    std::condition_variable cv_;      // 条件变量
    mutable std::mutex mutex_;        // 互斥锁
};

// 获取线程的调用栈
void getStackTrace(std::ostream& os) {
    os << "Stack Trace:\n";

    // 调用栈的大小
    const int maxFrames = 62;
    void* stackFrames[maxFrames];
    int capturedFrames = CaptureStackBackTrace(0, maxFrames, stackFrames, NULL);

    os << "Captured " << capturedFrames << " stack frames.\n";

    for (int i = 0; i < capturedFrames; ++i) {
        os << "  Frame " << i << ": " << stackFrames[i] << "\n";
    }
}

// 线程任务函数
DWORD WINAPI threadTask(LPVOID param) {
    InterruptManager* manager = static_cast<InterruptManager*>(param);
    std::unique_lock<std::mutex> lock(manager->mutex_);

    try {
        while (true) {
            // 检查中断标志
            if (manager->isInterrupted()) {
                throw ThreadInterruptedException(manager->getReason());
            }

            // 模拟阻塞操作
            std::cout << "Thread is running...\n";
            Sleep(1000); // 模拟工作
        }
    } catch (const ThreadInterruptedException& e) {
        // 捕捉到线程中断异常
        std::cout << "Thread interrupted: " << e.what() << "\n";

        // 显示线程的上下文（调用栈）
        std::ostringstream stackTraceStream;
        getStackTrace(stackTraceStream);
        std::cout << stackTraceStream.str();
    }

    return 0;
}

// 中断线程的函数
void interruptThread(InterruptManager& manager, const std::string& reason) {
    manager.interrupt(reason);
}

int main() {
    // 创建中断管理器
    InterruptManager manager;

    // 创建线程并运行任务
    HANDLE hThread = CreateThread(NULL, 0, threadTask, &manager, 0, NULL);

    // 模拟中断（5秒后中断线程）
    Sleep(5000);
    interruptThread(manager, "User requested interruption");

    // 等待线程结束
    WaitForSingleObject(hThread, INFINITE);
    CloseHandle(hThread);

    return 0;
}

关键点说明

  1. 自定义异常类 ThreadInterruptedException：

    • 用于表示线程任务被中断的异常，包含中断原因。

  2. 中断管理器类 InterruptManager：

    • 提供中断标志、中断原因和条件变量的管理功能。
    • interrupt方法用于中断线程，并设置中断原因。

  3. 获取调用栈 getStackTrace：

    • 使用Windows API CaptureStackBackTrace 获取当前线程的调用栈。
    • CaptureStackBackTrace 是Windows特有的函数，可以获取指定数量的调用栈帧。

  4. 线程任务函数 threadTask：

    • 使用Windows API CreateThread 创建线程。
    • 在线程任务中使用try-catch块捕捉ThreadInterruptedException。
    • 捕获异常后，显示中断信息和调用栈。

  5. 中断线程的函数 interruptThread：

    • 调用中断管理器的interrupt方法，中断线程并设置中断原因。

  6. 主函数 main：

    • 启动线程并运行任务。
    • 5秒后中断线程，并等待线程结束。

Windows 版本与 Linux 版本的区别

  1. 线程创建：

    • Linux 使用 std::thread 或 pthread。
    • Windows 使用 CreateThread 或 std::thread（C++11标准库）。

  2. 获取调用栈：

    • Linux 使用 backtrace 和 backtrace_symbols。
    • Windows 使用 CaptureStackBackTrace。

  3. 线程等待：

    • Linux 使用 join。
    • Windows 使用 WaitForSingleObject。

  4. 异常处理：

    • 在Windows上可以使用结构化的异常处理（SEH）或C++异常处理。

特点

  1. 自定义异常处理：

    • 使用自定义异常类捕捉线程中断，并在捕获到异常时显示中断信息和调用栈。

  2. 保存现场信息：

    • 通过CaptureStackBackTrace获取线程的调用栈，保存线程中断时的上下文。

  3. 灵活的中断机制：

    • 通过中断管理器动态控制线程的中断，并传递中断原因。

  4. 清晰的日志输出：

    • 中断信息和调用栈会输出到控制台，方便调试和分析。

应用场景

  1. 调试多线程程序：

    • 在调试过程中，捕捉线程中断异常并显示调用栈，帮助定位问题。

  2. 任务取消与恢复：

    • 在需要动态控制任务执行流程的场景中（如任务取消），使用中断机制并捕捉异常。

  3. 实时系统：

    • 在实时系统中，线程可能需要在中断时保存当前状态和调用栈，以便后续分析。

  4. 嵌入式系统：

    • 在嵌入式系统中，捕捉异常并保存现场信息，方便调试复杂的任务调度。

总结

以上Windows版本的示例代码展示了如何在线程任务被中止时捕捉异常并显示任务被中断的信息和现场。通过使用Windows API和自定义异常处理机制，可以实现类似Linux版本的功能。这种方法适用于调试多线程程序、任务取消与恢复、实时系统和嵌入式系统等场景，能够帮助开发人员更好地分析和解决问题。

相关推荐
我真不会起名字啊12 分钟前
“深入浅出”系列之C++：（11）推荐一些C++的开源项目
c++·开源
csdn_aspnet32 分钟前
c++ 给定欧氏平面中的一组线可以形成的三角形的数量
c++·算法·平面
好好学习++2 小时前
【HF设计模式】06-命令模式
java·c++·设计模式·命令模式
王老师青少年编程2 小时前
gesp(C++五级)（12）洛谷：B4051：[GESP202409 五级] 小杨的武器
开发语言·数据结构·c++·算法·gesp·csp
ke_wu2 小时前
实现简单的TCP服务器
linux·服务器·c语言·网络·c++·网络协议·tcp/ip
轩源源2 小时前
数据结构——AVL树的实现
开发语言·数据结构·c++·avl树·函数模板·双旋·单旋
新知图书2 小时前
Linux C\C++方式下的文件I/O编程
c语言·开发语言·c++
啥也不会的研究僧2 小时前
【C++提高篇】—— C++泛型编程之模板基本语法和使用的详解
开发语言·c++
秋已杰爱3 小时前
string底层实现细节
开发语言·c++
热门推荐
01leetcode - 1769. Minimum Number of Operations to Move All Balls to Each Box02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03半导体应用系统一些小知识收集(strip&wafer mapping,EAP&scada)04Dell服务器升级ubuntu 22.04失败解决05密码学原理技术-第六章-introduction to pulibc-key cryptography06优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间07xgboost: Why not implement distributed XGBoost on top of spark08[Docker]使用Docker部署常见的中间件09渗透测试之SQLMAP工具详解 kali自带SQLmap解释 重点sqlmap --tamper 使用方式详解 搞完你就很nice了10怎样让音频速度变慢？请跟随以下方法进行操作