【知识点】std::thread::detach std::lock_guard std::unique_lock

最新推荐文章于 2024-07-19 10:45:18 发布
最新推荐文章于 2024-07-19 10:45:18 发布
阅读量1.4k 收藏 8
点赞数 34
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33673253/article/details/139619796
版权

在 C++11 中，std::thread 提供了并发编程的基础设施，使得我们可以创建和管理线程。std::thread 的 detach 方法是一种常用的线程管理方式，允许线程在后台独立运行，而不必与主线程同步或等待其完成。

std::thread::detach 方法

当你调用 std::thread 对象的 detach 方法时，线程将与其创建的 std::thread 对象分离，允许它在后台继续运行。当主线程（或其他线程）不再需要等待线程完成时，可以使用 detach 方法。

调用 detach 方法后，std::thread 对象将不再与创建的线程关联，并且无法使用 join 方法来等待线程结束。如果 std::thread 对象在未调用 detach 或 join 的情况下被销毁，会导致程序终止。

示例

下面是一个使用 std::thread::detach 方法的示例：

#include <iostream>
#include <thread>
#include <chrono>

void backgroundTask() {
    for (int i = 0; i < 5; ++i) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::cout << "Background task running: " << i + 1 << " seconds\n";
    }
    std::cout << "Background task completed.\n";
}

int main() {
    std::thread t(backgroundTask);  // 创建一个线程运行 backgroundTask 函数

    t.detach();  // 分离线程

    std::cout << "Main thread continues to run...\n";
    std::this_thread::sleep_for(std::chrono::seconds(3));
    std::cout << "Main thread completed.\n";

    return 0;
}

在这个示例中，backgroundTask 函数将在后台运行 5 秒，每秒打印一次消息。当主线程调用 t.detach() 分离线程后，它继续执行其自身的操作，不再等待 backgroundTask 完成。

注意事项

  1. 无法使用 join：一旦线程被分离，就不能再使用 join 方法来等待它完成。这意味着主线程无法确保分离的线程何时完成或是否成功完成。

  2. 线程资源管理：分离线程在后台运行，直到它完成或程序结束。确保分离的线程在程序结束前完成，以避免可能的资源泄漏或未定义行为。

  3. 适用场景：detach 适用于那些不需要同步或等待的后台任务，例如日志记录、定时任务或其他非关键任务。

  4. 确保线程完成：当主线程退出时，分离的线程可能仍在运行。为了确保所有分离线程在程序结束前完成，可以使用适当的同步机制，如条件变量或其他同步手段。

进一步的示例

以下示例展示了如何使用条件变量来确保所有分离的线程在主线程完成前都已完成：

#include <iostream>
#include <thread>
#include <vector>
#include <chrono>
#include <condition_variable>

std::mutex mtx;
std::condition_variable cv;
bool done = false;

void backgroundTask(int id) {
    std::this_thread::sleep_for(std::chrono::seconds(id));
    std::cout << "Thread " << id << " completed.\n";
    std::unique_lock<std::mutex> lock(mtx);
    done = true;
    cv.notify_all();
}

int main() {
    std::vector<std::thread> threads;

    for (int i = 1; i <= 5; ++i) {
        std::thread t(backgroundTask, i);
        t.detach();
    }

    std::unique_lock<std::mutex> lock(mtx);
    cv.wait(lock, []{ return done; });

    std::cout << "All threads completed.\n";

    return 0;
}

在这个示例中，使用条件变量 cv 和互斥锁 mtx 来确保所有分离的线程在主线程完成前都已完成。当一个分离线程完成其任务时，它通知主线程更新状态。

总结

std::thread::detach 方法使得线程在后台独立运行，主线程无需等待其完成。这种方法适用于不需要同步或等待的后台任务，但需要注意管理线程的生命周期和资源，以确保程序正常运行。

std::lock_guard 是 C++11 引入的一个便利类，用于在作用域内自动管理互斥锁的锁定和解锁。它主要用于确保在函数或代码块执行期间互斥锁被正确地锁定和解锁，即使在异常或提前返回的情况下，也能够确保互斥锁被正确释放。

std::lock_guard

基本用法

std::lock_guard 的主要目的是提供一种简单的方式来确保互斥锁在作用域结束时自动解锁。它通过 RAII（资源获取即初始化）机制来实现这一点。

示例
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_thread_id(int id) {
    std::lock_guard<std::mutex> lock(mtx);  // 锁定互斥锁
    std::cout << "Thread ID: " << id << std::endl;
    // 在作用域结束时，互斥锁会自动解锁
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，std::lock_guard 确保在 print_thread_id 函数内互斥锁 mtx 被锁定，并在函数结束时自动解锁。

工作原理

std::lock_guard 的构造函数接受一个互斥锁对象，并在构造时锁定互斥锁。它的析构函数会自动解锁互斥锁，因此，当 std::lock_guard 对象超出其作用域时，互斥锁会自动解锁。

template <typename Mutex>
class lock_guard {
public:
    explicit lock_guard(Mutex& m) : mutex(m) {
        mutex.lock();
    }

    ~lock_guard() {
        mutex.unlock();
    }

    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;

private:
    Mutex& mutex;
};

使用场景

std::lock_guard 适用于简单的锁定场景，不需要手动管理锁的生命周期。它在以下情况下非常有用：

  1. 保护临界区：确保在多线程环境中对共享资源的访问是安全的。
  2. 异常安全：即使在函数中抛出异常，std::lock_guard 也能确保互斥锁被正确解锁。

与 std::unique_lock 的比较

std::unique_lock 提供了更灵活的锁管理功能，例如延迟锁定、提前解锁、再次锁定等。相比之下，std::lock_guard 更简单，但功能也更有限。

std::unique_lock 示例
#include <iostream>
#include <thread>
#include <mutex>

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);  // 锁定互斥锁
    std::cout << "Thread ID: " << id << std::endl;
    // 可选：提前解锁
    lock.unlock();
    // 可选：再次锁定
    lock.lock();
    // 在作用域结束时，互斥锁会自动解锁
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，std::unique_lock 提供了更多的灵活性，可以提前解锁和再次锁定互斥锁。

总结

  • std::lock_guard 是一个简单的 RAII 机制，用于在作用域内自动管理互斥锁的锁定和解锁。
  • 它适用于简单的锁定场景，确保在异常或提前返回的情况下互斥锁被正确释放。
  • 对于需要更灵活锁管理的情况，可以使用 std::unique_lock。

std::unique_lock

std::unique_lock 是 C++11 引入的一个模板类，用于管理互斥锁的锁定和解锁。与 std::lock_guard 相比，std::unique_lock 提供了更强大的功能和更灵活的锁管理选项。它允许延迟锁定、提前解锁、再次锁定等操作，是一种更通用的互斥锁管理方式。

std::unique_lock 的功能和用法

基本用法

std::unique_lock 的基本用法与 std::lock_guard 类似，但它提供了更多的功能。以下是一个基本示例：

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

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);  // 锁定互斥锁
    std::cout << "Thread ID: " << id << std::endl;
    // 在作用域结束时，互斥锁会自动解锁
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，std::unique_lock 确保在 print_thread_id 函数内互斥锁 mtx 被锁定，并在函数结束时自动解锁。

延迟锁定

std::unique_lock 允许延迟锁定互斥锁，即在创建 std::unique_lock 对象时不立即锁定互斥锁。可以使用 defer_lock 标签来实现这一点：

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

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);  // 不立即锁定互斥锁
    // 需要时手动锁定
    lock.lock();
    std::cout << "Thread ID: " << id << std::endl;
    // 自动解锁
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，互斥锁在创建 std::unique_lock 对象时并未被锁定，而是在需要时手动锁定。

提前解锁

可以使用 unlock 方法提前解锁互斥锁：

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

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx);  // 锁定互斥锁
    std::cout << "Thread ID: " << id << std::endl;
    lock.unlock();  // 提前解锁
    // 其他不需要锁定的操作
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，互斥锁在 print_thread_id 函数内提前解锁，以便进行其他不需要锁定的操作。

试图锁定

可以使用 try_lock 方法尝试锁定互斥锁而不阻塞：

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

std::mutex mtx;

void print_thread_id(int id) {
    std::unique_lock<std::mutex> lock(mtx, std::try_to_lock);  // 尝试锁定互斥锁
    if (lock.owns_lock()) {
        std::cout << "Thread " << id << " successfully locked the mutex." << std::endl;
    } else {
        std::cout << "Thread " << id << " failed to lock the mutex." << std::endl;
    }
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

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

    return 0;
}

在这个示例中，try_lock 方法尝试锁定互斥锁。如果锁定成功，owns_lock 方法将返回 true；否则返回 false。

std::unique_lock 的构造函数

std::unique_lock 有多个构造函数，可以用于不同的锁定策略：

  • 默认构造：不锁定互斥锁。
  • 立即锁定构造：在创建时立即锁定互斥锁。
  • 延迟锁定构造：在创建时不锁定互斥锁，可以稍后手动锁定。
  • 尝试锁定构造：尝试锁定互斥锁。

详细示例

下面是一个更详细的示例，展示了如何使用 std::unique_lock 进行延迟锁定、提前解锁和尝试锁定：

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

std::mutex mtx;

void worker(int id) {
    std::unique_lock<std::mutex> lock(mtx, std::defer_lock);  // 延迟锁定
    std::cout << "Thread " << id << " is waiting to lock the mutex..." << std::endl;

    // 尝试锁定
    if (lock.try_lock()) {
        std::cout << "Thread " << id << " has locked the mutex." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
        lock.unlock();
        std::cout << "Thread " << id << " has unlocked the mutex." << std::endl;
    } else {
        std::cout << "Thread " << id << " failed to lock the mutex." << std::endl;
    }
}

int main() {
    std::thread t1(worker, 1);
    std::thread t2(worker, 2);

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

    return 0;
}

在这个示例中，两个线程都尝试锁定同一个互斥锁。使用 std::unique_lock 的延迟锁定和尝试锁定机制，线程可以在失败时进行不同的处理。

总结

  • std::unique_lock 提供了更灵活的锁管理功能，包括延迟锁定、提前解锁和尝试锁定。
  • 它比 std::lock_guard 更强大，但也更复杂，适用于需要灵活锁管理的场景。
  • 通过理解 std::unique_lock 的使用，可以更好地管理多线程环境下的资源同步，编写更安全和高效的代码。
好悬给我拽开线
关注
关于C++使用thread的detach函数之后
qq_44879626的博客
03-06 1136
定义一个子线程初始函数，当创建一个子线程时，如果传入的是类对象的引用，那么会重新创立一个类对象，但是如果使用detach的话，如何保证安全。就是如何保证主线程运行完前完成创建副本对象。将对象先转换一下就可以。 std::thread myobj(myprintf2, Node(myp);//去除Node后不能保证安全 智能指针的写法： unique_ptr<int> p; #include<iostream> using namespace std; void mypri
linux C++ std::thread::detach()函数（线程分离）
Dontla的博客
06-05 3149
linux C++ std::thread::detach()函数（线程分离）
理解 std::thread::detach
C++ 爱好者 make_it_simple888
09-03 818
从而变成了 detach 在启动的时候是以 detach 方式启动（不阻塞其他任何线程），同时 main 以代码的方式 等待（join）这个detach 线程。可以看到，由于 UI线程没有等待 record 线程，所以， record 是在 UI线程执行的过程中自己独立执行完成的。下面我们就来模拟 record 线程确实是比较慢，UI线程都被用户关闭窗口了，还没有把所有的录制数据写入到本地文件。中，我们看到了，如果所有线程都是一开始就在 main 函数中创建好的，那么只需要有一个 join 函数就足够了。
C++11thread之detach()与join()的函数对比
热门推荐
量化开发技术点集锦
02-27 1万+
在声明一个std::thread对象之后，都可以使用detach和join函数来启动被调线程，区别在于两者是否阻塞主调线程。 （1）当使用join()函数时，主调线程阻塞，等待被调线程终止，然后主调线程回收被调线程资源，并继续运行； （2）当使用detach()函数时，主调线程继续运行，被调线程驻留后台运行，主调线程无法再取得该被调线程的控制权。当主调线程结束时，由运行时库负责清理与被调线程相...
std::thread中.detach()和.join()
最新发布
Yakusha的博客
07-19 993
在创建后，如果离开作用域之前未调用.detach()或.join()，程序会崩溃。使用.detach()允许线程在后台独立运行，而使用.join()则等待线程完成执行。你的示例中，.detach()使线程独立运行，允许主线程继续处理新的连接。
std::thread进阶同步课：std::unique_lock与std::shared_lock的高级运用
[std::thread进阶同步课：std::unique_lock与std::shared_lock的高级运用](https://nixiz.github.io/yazilim-notlari/assets/img/thread_safe_banner_2.png) # 1. std::thread与并发基础知识 本章将为您奠定C++11...
【C++并发编程】：std::unordered_map线程安全的正确操作
[【C++并发编程】：std::unordered_map线程安全的正确操作](https://nixiz.github.io/yazilim-notlari/assets/img/thread_safe_banner_2.png) # 1. 并发编程与线程安全基础 在现代软件开发中，随着多核处理器的普及...
std::thread任务管理指南：如何构建高效线程任务队列
![std::thread任务管理指南：如何构建高效线程任务队列]...本章将引领读者了解`std::thread`的基础知识，为深入探讨线程任务队列的构建打下坚实的基础。 #
std::thread案例精选：多线程网络通信架构与实现全攻略
而`std::thread`是C++标准库中用于实现多线程的关键组件，它提供了一种简便的方法来创建和管理线程，是实现并发执行的基础。 C++11标准中引入了`std::thread`，它简化了线程的创建和管理过程。程序员可以通过`std:
C++多线程调试秘技：std::thread常见问题与高效解决方案
C++多线程编程概述与std::thread简介 ## 1.1 C++多线程编程的背景和意义 C++多线程编程是一种先进的编程技术，它可以在程序运行时同时执行多个任务，提高程序的执行效率和响应速度。这种技术在处理耗时的I/O操作和...
std::thread和detach()
weixin_51883798的博客
05-23 290
【代码】std::thread和detach()
thread --- detach()的使用
shunlu5586的博客
11-11 5799
thread --- detach()
std::thread的join和detach
qq_34915586的博客
11-21 4689
C++中的thread对象通常来说表达了执行的线程（thread of execution），这是一个OS或者平台的概念。 thread一旦创建，就开始执行，并且与创建它的线程有一定的关系。 thread创建后，需要在调用线程中需要指明是join还是detach，否则会发生错误。 1、当thread::join()函数被调用后，调用它的线程会被block，直到线程的执行被完成。基本上，这是一...
c++线程detach
bikong7的博客
06-14 887
当进程终止时，内核遍历PCB中的资源列表，释放所有分配给该进程的资源。这包括关闭所有打开的文件描述符，释放内存页，清理信号量和定时器，以及终止所有线程。在main结束之前，对于没有detach的线程，需要用join等待线程结束，对于使用了detach的线程，可以通过一些同步机制，通知子线程结束，然后主线程再结束。// 主线程结束后，即使子线程还没结束，也会被操作系统回收。// 进程结束后，即使子线程还没结束，也会被操作系统回收。当进程退出时，这个后台线程会被pcb回收，不会报错。一旦线程被分离，原始的。
C++线程对象std::thread之join和detach
imoisture的博客
07-23 1126
C++11 之后有了标准的线程库：std::thread。Linux环境下，C++的库底层是对pthread的封装。一旦一个std::thread绑定了一个函数（如通过有参构造函数构造了一个std::thread对象），则此对象就会立刻开始执行传递进来的函数。
std::thread的join()和detach()
weixin_41440739的博客
04-27 460
std::thread：代表单独的线程对象。同一进程中的线程共享同一个地址空间。一个初始化的thread对象代表一个激活的线程，该对象是joinable的，有唯一的线程id。一个只构造但没有初始化的线程对象是non-joinable的线程，所有non-joinable的线程的id都是一样的。对joinable的线程执行join()或者detach()操作后，该线程就变成non-joinable的了。 构造函数： default (1) thread() noexcept; initialization (
Thread Detach
月上纱窗的专栏
06-30 348
thread detach
C++11 - 使用std::thread::join()/std::thread::detach()方法需要注意的点
HW140701的博客
02-26 2693
1 调用std::thread::join()方法等待线程退出时的示例问题程序 #include <iostream> #include "conio.h" #include <memory> #include <thread> #include <atomic> class BaseThread { public: typedef std::shared_ptr<BaseThread> ptr; BaseThread() { m_
thread::detach
farmwang的专栏
08-13 1487
detach()用于让线程不受句柄控制! 终止的线程所占用的资源也并不会随着线程的终止而得到释放! __detachstate，表示新线程是否与进程中其他线程脱离同步， 如果设置为PTHREAD_CREATE_DETACHED 则新线程不能用pthread_join()来同步，且在退出时自行释放所占用的资源。缺省为PTHREAD_CREATE_JOINABLE状态。这个
std::this_thread和std::thread区别
01-11
std::thread提供了一些成员函数，如join()和detach()，用于等待线程完成或分离线程。 下面是一个示例，演示了std::this_thread和std::thread的区别： ```cpp #include #include <thread> #include void thread...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值