std::thread(线程) 学习记录

最新推荐文章于 2024-06-22 21:03:04 发布
最新推荐文章于 2024-06-22 21:03:04 发布
阅读量227 收藏
点赞数
分类专栏： C++ 文章标签： thread c++
原文链接：https://blog.csdn.net/weixin_40087851/article/details/82685510
版权

std::thread(线程) 学习记录

1. thread的创建以及面临的问题

1.1 thread.cpp

//创建线程，Ｃ++中提供头文件thread，使用std的thread实例化一个线程对象的创建
//std::thread在＃include头文件中声明，因此使用std::thread需要包含＃include头文件

#include <iostream>
#include <thread>
#include <glog/logging.h>

using namespace std;

void thread1()
{
    for(int i = 0; i < 20; ++i)
    {
        cout<<"thread1..."<<endl;
        //cout<<endl;
    }
}

void thread2()
{
    for(int i = 0; i < 20; ++i)
    {
        cout<<"thread2..."<<endl;
        //cout<<endl;
    }
}

int main(int argc, char* argv[])
{
    google::InitGoogleLogging(argv[0]);
    FLAGS_logtostderr = 1;        //设置只在终端打印信息
    FLAGS_colorlogtostderr = 1;

    thread th1(thread1);  //实例化一个线程对象th1，该线程开始执行
    thread th2(thread2);

    LOG(INFO)<<"main...";

    return 0;

    //结果分析：上例是有问题的，因为在创建了线程后，线程开始执行，但是主线程main()并没有停止脚步，仍然继续执行然后退出，
    //此时线程对象还是joinable(可结合的)，线程仍然存在但指向它的线程对象已经销毁，所以会中断．
    //那么如何保证子线程执行完退出后再退出主线程呢？
}

1.2 终端编译

在这里插入图片描述

1.3 编译结果

在这里插入图片描述

2. thread::join( )

2.1 thread.cpp

//解决方法之一：thread::join()
//使用join接口可以解决上述问题，join的作用是让主线程等待直到该子线程执行结束．

#include <iostream>
#include <glog/logging.h>
#include <thread>

using namespace std;

void thread1()
{
    for(int i = 0; i < 10; ++i)
    {
        cout<<"thread1..."<<endl;
        //cout<<endl;
    }
}

void thread2()
{
    for(int i = 0; i < 10; ++i)
    {
        cout<<"thread2..."<<endl;
        //cout<<endl;
    }
}

int main(int argc, char* argv[])
{
    google::InitGoogleLogging(argv[0]);
    FLAGS_logtostderr = 1;          //设置只在终端打印信息
    FLAGS_colorlogtostderr = 1;

    thread th1(thread1);  //实例化一个线程对象th1，该线程开始执行
    thread th2(thread2);

    LOG(INFO)<<"********"<<th1.joinable();

    th1.join();

    LOG(INFO)<<"********"<<th1.joinable();

    th2.join();

    LOG(WARNING)<<"main...";

    return 0;
}

//结果分析：此时就可以正常执行子线程了，同时注意最后一个输出，说明了main是等待子线程结束后才继续执行的．
//需要注意的是，线程对象执行了join后就不再joinable(判断线程是否可以加入等待)了．所以只能join一次．
//joinable：检查线程是否可以被join．检查当前的线程对象表示了一个活动的执行过程，有默认构造函数创建的线程是不能被join的．
//另外，如果某个线程已经执行完，但是没有被join的话，该线程依然被认为是一个活动的线程，因此也是可以被join的．

2.2 编译结果

在这里插入图片描述

3. thread::detach( )

3.1 thread.cpp

//解决方法：thread::detach()
//将当前线程对象所代表的执行实例与该线程对象分离,使得线程的执行可以单独进行.一旦线程执行完毕,它所分配的资源将会被释放.
//detach是用来分离线程,这样线程可以独立执行,不过这样由于没有thread对象指向该线程而失去了对它的控制.
//当对象析构时,线程会继续在后台执行,但是当主程序退出时并不能保证线程执行完.
//如果没有良好的控制机制或者这种后台线程比较重要,最好不用detach而使用join.

#include <iostream>
#include <glog/logging.h>
#include <thread>

using namespace std;

void thread1()
{
    for(int i = 0; i < 10; ++i)
    {
        cout<<"thread1..."<<endl;
    }
}

void thread2()
{
    for(int i = 0; i < 10; ++i)
    {
        cout<<"thread2..."<<endl;
    }
}

int main(int argc, char* argv[])
{
    google::InitGoogleLogging(argv[0]);
    FLAGS_logtostderr = 1;
    FLAGS_colorlogtostderr = 1;

    thread th1(thread1);
    thread th2(thread2);

    th1.detach();
    th2.detach();

    LOG(ERROR)<<"main...";

    return 0;

}

//结果分析: 子线程与主程序分开执行,当对象析构时,子线程会继续在后台执行.

3.2 编译结果

在这里插入图片描述

4. mutex

mutex是防止不同的线程同时操作同一个共享数据.

4.1 mutex_test.cpp

//头文件mutex是用来保证线程同步的,防止不同的线程同时操作同一个共享数据.
//#include:该头文件主要声明了与互斥量相关的类,
//包括std::mutex系列类,std::lock_guard,std::unique_lock

#include <iostream>
#include <thread>
#include <mutex>
#include <glog/logging.h>

using namespace std;

mutex m;

int cnt = 10;

void thread1()
{
    while(cnt > 5)
    {
        m.lock();
        if(cnt > 0)
        {
            --cnt;
            cout<<cnt<<endl;
        }
        m.unlock();
    }
}

void thread2()
{
    while(cnt > 0)
    {
        m.lock();
        if(cnt > 0)
        {
            cnt -= 10;
            cout<<cnt<<endl;
        }
        m.unlock();
    }
}

int main(int argc, char* argv[])
{
    google::InitGoogleLogging(argv[0]);
    FLAGS_logtostderr = 1;
    FLAGS_colorlogtostderr = 1;

    thread th1(thread1);
    thread th2(thread2);

    th1.join();
    th2.join();

    LOG(WARNING)<<"main...";

    return 0;
}

4.2 编译结果

在这里插入图片描述

  • 结果分析：mutex是不安全的，如果当一个线程在解锁之前就异常退出了，那么其他被阻塞的线程就无法进行下去．

5. std::lock_guard

5.1 lock_guard.cpp

使用lock_guard则相对安全，它是基于作用域的，能够自解锁．

//使用lock_guard则相对安全，它是基于作用域的，能够自解锁，当该对象创建时，它会像m.lock()一样获得互斥锁
//当生命周期结束时，它会自动析构(unlock)，不会因为某个线程异常退出而影响其他线程．


#include <iostream>
#include <thread>
#include <mutex>
#include <glog/logging.h>

using namespace std;

mutex m;

int cnt = 10;

void thread1()
{
    while(cnt > 5)
    {
        lock_guard<mutex> lock(m);
        if(cnt > 0)
        {
            --cnt;
            cout<<cnt<<endl;
        }
    }
}

void thread2()
{
    while(cnt > 0)
    {
        lock_guard<mutex> lock(m);
        if(cnt > 0)
        {
            cnt -= 2;
            cout<<cnt<<endl;
        }
    }
}

int main(int argc, char* argv[])
{
    google::InitGoogleLogging(argv[0]);
    FLAGS_logtostderr = 1;
    FLAGS_colorlogtostderr = 1;

    thread th1(thread1);
    thread th2(thread2);

    th1.join();
    th2.join();

    LOG(WARNING)<<"main...";

    return 0;
}

5.2 编译结果

在这里插入图片描述

春至冬去
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
std::thread 学习记录
Archi-dreamer的博客
08-02 343
std::thread, multi-thread, C++11
C++:线程(std::thread)
u012422855的专栏
06-20 793
1.创建一个线程　　创建线程比较简单，使用std的thread实例化一个线程对象就创建完成了，示例： 1 #include &lt;iostream&gt; 2 #include &lt;thread&gt; 3 using namespace std; 4 5 void t1() //普通的函数，用来执行线程 6 { 7 for (int i = 0; i &lt; 20...
C++11并发之std::thread
hyl999的专栏
03-06 1349
知识链接： C++11 并发之std::mutex C++11 并发之std::atomic 本文概要： 1、成员类型和成员函数。 2、std::thread 构造函数。 3、异步。 4、多线程传递参数。 5、join、detach。 6、获取CPU核心个数。 7、CPP原子变量与线程安全。 8、lambda与多线程。 9、时间等待相关问题。 10、线程功能拓...
线程thread 使用，和运行结束判断
08-11 979
Console.WriteLine(DateTime.Now + "thread 等待结束!// 默认是前台线程。//线程等待200ms。
std::thread（线程）
热门推荐
傻月菇凉的博客
09-13 4万+
转自：https://www.cnblogs.com/whlook/p/6573659.html 创建线程 创建线程比较简单，C++提供头文件thread，使用std的thread实例化一个线程对象创建。 std::thread 在 #include 头文件中声明，因此使用 std::thread 时需要包含 #include 头文件。 #include&lt;iostream&gt...
C++：std::thread：线程用法
C++ JAVA的专栏
01-06 7699
C++：std::thread：线程用法
C++ std::thread使用
mayue_web的博客
10-16 1万+
C++ std::thread 使用
C++11 并发指南之std::thread 详解
08-25
std::thread 类提供了创建和管理线程的功能，允许开发者在程序中创建多个线程，从而实现并发编程。 首先，我们需要了解 std::thread 类的构造函数。std::thread 类有四种构造函数： 1.默认构造函数，创建一个空的 ...
c++11中关于std::thread的join的详解
08-26
C++11引入了std::thread库，提供了对多线程编程的支持。std::thread库提供了两个基本操作：join和detach。join操作用于回收线程资源，避免资源泄露；detach操作用于将线程与创建线程的线程分离，变成后台线程。在...
C++11中多线程编程-std::async的深入讲解
12-16
C++11中提供了异步线程接口std::async，std::async是异步编程的高级封装，相对于直接使用std::thread，std::async的优势在于: 1、std::async会自动创建线程去调用线程函数，相对于低层次的std::thread，使用起来非常...
C++11并发编程:多线程std::thread
08-26
C++11并发编程：多线程std::thread C++11引入了thread类，大大降低了多线程使用的复杂度。原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需...
std::thread 并发测试
01-12
测试多并发的性能及同步
std::thread的三种函数调用表示方法
weixin_64676663的博客
05-23 2857
主要解决thread调用函数时，对参数类型的要求，解决一些细节错误
多线程/std::thread线程退出方式详解
river.qu
06-26 7893
本文主要描述了如何优雅退出std::thread线程的执行，并与WinAPI线程退出方式进行了横向比较。
C++线程运行的开始和结束（代码演示）
咩咩的博客
10-13 4447
一 主线程： int main() { //程序运行起来，生成一个进程，该进程所属的主线程开始自动运行 cout << " I love China" << endl;//实际上这是主线程在执行，主线程从main()函数返回，则整个进程执行完毕。 return 0; } 主线程从main()函数开始执行，那么我们自己创建的线程，也需要从一个函数开始运行（初始函数）一旦这个函数运行完毕，就代表我们这个线程运行结束。 整个进程是否执行完毕的标志是：主线程是否执行完，如果主线
C++多线程小记
cabinx的博客
06-16 366
多线程实现队列数据存取的过程中，遇到一些多线程编程的基础问题，记录一下。 简要类比举例，新建了类作为对象： class aClass{ sturct structA{ .... }; bool processData(int a,char *b); }; 在主函数文件中有子函数需要对对象中的结构体数据进行处理： int processClassStruct(aClass &a, aClass::st...
关于STAThread
竹君子之家
07-29 2417
C#的关键字 STAThread即 single-threaded apartment。每个Thread都有一个关于ApartmentState的属性，可以把它设置为：STA或者MTA，或者UNKNOWN。当你想指定工程的启动窗口的时候，你需要在该窗口类中申明一个Main()方法，并为这个方法设置[STAThread]属性。详细信息，清查阅MSDN中关于Threading和COM Interop和
std::thread使用及实现原理精讲(全)
红军不怕远征难，万水千山只等闲
03-22 2237
线程创建和销毁是昂贵的操作，应尽量避免频繁创建和销毁线程。线程间共享数据时，要确保数据访问的线程安全性。尽量避免在多个线程中访问和修改全局变量或静态变量，除非这些变量是线程安全的。使用 std::thread 时，要确保在程序结束前对所有线程调用 join() 或 detach()，以避免资源泄漏。总之，std::thread 为 C++ 提供了强大而灵活的多线程支持，使得开发者能够更容易地编写并行程序。然而，多线程编程也带来了额外的复杂性和挑战，需要开发者仔细考虑线程间的数据共享和同步问题。
C语言第17篇：预处理详解
最新发布
2302_78977491的博客
06-22 772
C语言设置了一些预定义符号，可以直接使用。预定义符号也是在预处理期间处理的。__FILE__ //进行编译的源文件__LINE__ //文件当前的行号__DATE__ //文件被编译的日期__TIME__ //文件被编译的时间__STDC__ //如果编译器遵循ANSI C，其值为1, 否则未定义int main()printf("进行编译的源文件:%s\n", __FILE__);printf("当前文件的行号:%d\n", __LINE__);
std::thread新建线程
09-21
`std::thread`是C++11引入的一个多线程库，用于创建和管理线程。可以通过`std::thread`类的构造函数来创建新的线程，并指定待执行的函数或可调用对象。 以下是使用`std::thread`新建线程的示例代码： ```cpp #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值