c++并发编程面试题

激昂～逐流

于 2024-08-13 17:56:33 发布

阅读量248

点赞数 2

分类专栏： C++面试题文章标签： c++ 开发语言编程面试题

本文链接：https://blog.csdn.net/qq_71286244/article/details/141169720

版权

C++面试题专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. C++中lock_guard和unique_lock的区别？

在C++中，lock_guard和unique_lock都是用于管理互斥锁的类，它们提供了一种 RAII（Resource Acquisition Is Initialization）机制来确保锁在作用域结束时自动释放。尽管它们的目的相似，但在功能和适用场景上有一些区别：

功能上的区别

lock_guard:

主要用于一个简单的锁管理场景。
在构造时自动获取锁，并在析构时自动释放锁。
不支持手动解锁或重新锁定功能，锁的获取和释放是严格绑定到对象的生命周期。

unique_lock:

提供更丰富的功能。
可以在构造时指定是否立即锁定，可以在作用域内手动解锁和重新锁定。
支持状态查询（例如，检测锁是否被持有）和条件变量的等待功能（通过与条件变量配合使用）。
允许移动，但不可复制。

性能

lock_guard相对更轻量，适合简单的加锁需求。
unique_lock因为功能更丰富，可能在某些情况下性能稍逊，但提供了更多灵活性。

使用场景

使用 lock_guard:

当你只需要简单的锁保护，且生命周期管理是清晰的情况下，使用 lock_guard 是最佳选择。

使用 unique_lock:

当你需要更复杂的锁逻辑，例如需要在某个条件下释放锁，或者需要与条件变量一起使用时，选择 unique_lock 更为合适。

示例代码

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

std::mutex mtx;  

void function_with_lock_guard() {  
    std::lock_guard<std::mutex> lock(mtx);  
    // 保护的代码块  
    std::cout << "Lock guard is holding the lock." << std::endl;  
}  

void function_with_unique_lock() {  
    std::unique_lock<std::mutex> lock(mtx);  
    // 保护的代码块  
    std::cout << "Unique lock is holding the lock." << std::endl;  

    // 这里可以手动释放锁  
    lock.unlock();  
    std::cout << "Lock has been released." << std::endl;  

    // 重新锁定  
    lock.lock();  
    std::cout << "Lock is locked again." << std::endl;  
}  

int main() {  
    std::thread t1(function_with_lock_guard);  
    std::thread t2(function_with_unique_lock);  

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

    return 0;  
}

总结

在大多数情况下，如果只需要简单的锁定和解锁，建议使用 lock_guard。如果需要更复杂的锁操作或条件变量的支持，选择 unique_lock。

2. C++中thread的join和detach的区别？

在C++中，std::thread提供了两种主要的线程管理方法：join和detach。它们在处理线程的生命周期和回收资源方面有重要的区别。

join

功能: 当你调用join方法时，主线程会等待被调用的线程完成执行。
阻塞行为: 调用join会阻塞调用线程，直到目标线程结束。
资源管理: 一旦调用了join，相关的线程资源会被正确地清理，确保没有资源泄漏。
使用场景: 通常在你需要确保一个线程完成其工作后再继续执行主线程的情况下使用。例如，当线程完成了一项重要的计算或任务，并且主线程需要该结果时。

#include <iostream>  
#include <thread>  

void threadFunction() {  
    std::cout << "Thread is running." << std::endl;  
}  

int main() {  
    std::thread t(threadFunction);  
    t.join();  // 等待线程t执行完毕  
    std::cout << "Thread has finished." << std::endl;  
    return 0;  
}

detach

功能: 当你调用detach时，被调用的线程会独立于创建它的线程继续执行。
非阻塞行为: 调用detach后，主线程不会阻塞，线程会在后台运行。
资源管理: 一旦线程被分离，主线程无法再与之交互，也不能调用join。系统会自动管理这个线程的资源，因此可能会出现资源泄漏或未定义的行为，特别是如果主线程在后台线程完成前就退出。
使用场景: 通常在你希望后台线程独立执行一些任务，同时不需要等待它完成的情况下使用。例如，处理日志记录或异步计算。

#include <iostream>  
#include <thread>  

void threadFunction() {  
    std::cout << "Thread is running." << std::endl;  
}  

int main() {  
    std::thread t(threadFunction);  
    t.detach();  // 将线程t分离，不等待其结束  
    std::cout << "Thread has been detached." << std::endl;  
    
    // 给线程一些时间完成任务（仅用于示范，实际应用中应使用更安全的方法）  
    std::this_thread::sleep_for(std::chrono::seconds(1));  
    return 0;  
}

总结

join: 等待一个线程完成执行，适用于需要同步的场合。
detach: 使线程独立于主线程执行，适用于后台处理或不需要同步的场合。

在使用这些方法时，确保理解线程的生命周期，以避免潜在的资源泄漏或未定义行为。

3. C++中jthread和thread的区别？

在C++20中，引入了std::jthread，这是对std::thread的一个改进。以下是std::jthread和std::thread之间的主要区别：

自动管理线程生命周期

std::jthread:

自动管理线程的生命周期，使用了RAII（资源获取即初始化）原则。
如果std::jthread对象离开作用域，它会自动调用join()，确保线程在对象析构时被正确地加入（join），避免了遗留的线程。

std::thread:

需要手动管理线程的生命周期，调用join()或detach()，如果不处理，将导致程序异常终止。

更简便的使用

std::jthread:

通过构造函数直接接收可调用对象和参数，并在析构时自动进行join，使用起来更为方便。

std::thread:

需要在确定线程应当结束时手动调用join()，增加了出错的可能性。

支持可中断的线程

std::jthread:

提供了request_shutdown()方法来请求线程的终止。线程可以在合适的位置检查这个请求，从而安全地退出。

std::thread:

没有内置的中断机制，终止线程需要使用其他方法（如设置标志位、使用条件变量等），不够灵活。

使用方法示例

#include <iostream>  
#include <thread>  

void threadFunction(std::stop_token stoken) {  
    while (!stoken.stop_requested()) {  
        // 执行一些任务  
        std::this_thread::sleep_for(std::chrono::milliseconds(100));  
    }  
    std::cout << "Thread exiting." << std::endl;  
}  

int main() {  
    std::jthread jt(threadFunction);  // 自动管理线程的生命周期  
  
    // 模拟主线程工作  
    std::this_thread::sleep_for(std::chrono::seconds(1));  

    // 请求线程结束  
    jt.request_stop();   
    return 0; // 自动调用 jt.join()，确保线程结束  
}