c++11&14-多线程要点汇总

在C++11以前，C++的多线程编程均需依赖系统或第三方接口实现，一定程度上影响了代码的移植性。C++11中，引入了boost库中的多线程部分内容，形成C++标准，形成标准后的boost多线程编程部分接口基本没有变化，这样方便了以前使用boost接口开发的使用者切换使用C++标准接口，很容易把boost接口升级为C++标准接口。

我们通过如下几部分介绍C++11多线程方面的接口及使用方法。

1. std::thread

std::thread为C++11的线程类，使用方法和boost接口一样，非常方便，同时，C++11的std::thread解决了boost::thread中构成参数限制的问题，我想这都是得益于C++11的可变参数的设计风格。

我们通过如下代码熟悉下std::thread使用风格:

//c11.cpp
#include <iostream>
#include <thread>
void threadfun1()
{
 std::cout << "threadfun1 - 1\r\n" << std::endl;
 std::this_thread::sleep_for(std::chrono::seconds(1));
 std::cout << "threadfun1 - 2" << std::endl;
}
void threadfun2(int iParam, std::string sParam)
{
 std::cout << "threadfun2 - 1" << std::endl;
 std::this_thread::sleep_for(std::chrono::seconds(5));
 std::cout << "threadfun2 - 2" << std::endl;
}
int main()
{
 std::thread t1(threadfun1);
 std::thread t2(threadfun2, 10, "abc");
 t1.join();
 std::cout << "join" << std::endl;
 t2.detach();
 std::cout << "detach" << std::endl;
}

注意编译时要使用：g++ c11.cpp -lpthread

运行结果：

threadfun1 - 1
threadfun2 - 1
threadfun1 - 2
join
detach

2. std::atomic

std::atomic为C++11封装的原子数据类型。
什么是原子数据类型？从功能上看，简单地说，原子数据类型不会发生数据竞争，能直接用在多线程中而不必我们用户对其进行添加互斥资源锁的类型。从实现上来看，我们可以理解为这些原子类型内部自己加了锁。

我们下面通过一个测试例子说明原子类型std::atomic的特点。

我们使用10个线程，把std::atomic类型的变量iCount从10减到1。

//c11.cpp
#include <thread>
#include <atomic>
#include <stdio.h>
#include <iostream>
#include <list>
std::atomic<bool> bIsReady(false);
std::atomic<int> iCount(10);
void threadfun1()
{
 if (!bIsReady) {
  std::this_thread::yield();
 }
 while (iCount > 0)
 {
  printf("iCount:%d\r\n", iCount--);
 }
}
int main()
{
 std::list<std::thread> lstThread;
 for (int i = 0; i < 10; ++i)
 {
  lstThread.push_back(std::thread(threadfun1));
 }
 for (auto& th : lstThread)
 {
  th.join();
 }
}

运行结果：

iCount:10
iCount:9
iCount:8
iCount:7
iCount:6
iCount:5
iCount:4
iCount:3
iCount:2
iCount:1

从上面的结果可以看到，iCount的最小结果是1，没有出现小于等于0的情况，大家可以把iCount改成100甚至1000看看，可能会更直观一点。

3. std::condition_variable

C++11中的std::condition_variable就像Linux下使用pthread_cond_wait和pthread_cond_signal一样，可以让线程休眠，直到被唤醒，然后再重新执行。线程等待在多线程编程中使用非常频繁，经常需要等待一些异步执行的条件的返回结果。

代码如下：

#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable
std::mutex mtx;
std::condition_variable cv;
bool ready = false;
void print_id(int id) {
 std::unique_lock<std::mutex> lck(mtx);
 while (!ready) cv.wait(lck); //线程将进入休眠
 // ...
 std::cout << "thread " << id << '\n';
}
void go() {
 std::unique_lock<std::mutex> lck(mtx);
 ready = true;
 cv.notify_all();
}
int main()
{
 std::thread threads[10];
 // spawn 10 threads:
 for (int i = 0; i<10; ++i)
  threads[i] = std::thread(print_id, i);
 std::cout << "10 threads ready to race...\n";
 go(); // go!
 for (auto& th : threads) th.join();
 return 0;
}

运行结果：

10 threads ready to race...
thread 0
thread 1
thread 2
thread 3
thread 4
thread 5
thread 6
thread 7
thread 8
thread 9

上面的代码，在调用go函数之前，10个线程都处于休眠状态，当cv.notify_all()运行后，线程休眠结束，继续往下运行，最终输出如上结果。

以上就是c++11&14-多线程知识汇总的详细内容，更多关于c++11&14 多线程使用的资料请关注我们其它相关文章！

赞 (0)

相关推荐

  • C++多线程中的锁和条件变量使用教程

    在做多线程编程时,有两个场景我们都会遇到: 多线程访问共享资源,需要用到锁: 多线程间的状态同步,这个可用的机制很多,条件变量是广泛使用的一种. 今天我用一个简单的例子来给大家介绍下锁和条件变量的使用. 代码使用C++11 示例代码 #include <iostream> #include <mutex> #include <thread> #include <condition_variable> std::mutex g_mutex; // 用到的全局锁

  • C++基于消息队列的多线程实现示例代码

    前言 实现消息队列的关键因素是考量不同线程访问消息队列的同步问题.本实现涉及到几个知识点 std::lock_guard 介绍 std::lock_gurad 是 C++11 中定义的模板类.定义如下: template <class Mutex> class lock_guard; lock_guard 对象通常用于管理某个锁(Lock)对象,因此与 Mutex RAII 相关,方便线程对互斥量上锁,即在某个 lock_guard 对象的声明周期内,它所管理的锁对象会一直保持上锁状态:而 l

  • C++11并发编程:多线程std::thread

    一:概述 C++11引入了thread类,大大降低了多线程使用的复杂度,原先使用多线程只能用系统的API,无法解决跨平台问题,一套代码平台移植,对应多线程代码也必须要修改.现在在C++11中只需使用语言层面的thread可以解决这个问题. 所需头文件<thread> 二:构造函数 1.默认构造函数 thread() noexcept 一个空的std::thread执行对象 2.初始化构造函数 template<class Fn, class... Args> explicit th

  • C++实现多线程查找文件实例

    主要是多线程的互斥 文件 的查找 多线程互斥的框架 复制代码 代码如下: //线程函数  UINT FinderEntry(LPVOID lpParam)  {      //CRapidFinder通过参数传递进来       CRapidFinder* pFinder = (CRapidFinder*)lpParam;      CDirectoryNode* pNode = NULL;      BOOL bActive = TRUE; //bActive为TRUE,表示当前线程激活   

  • C++11 并发指南之多线程初探

    C++11 自2011年发布以来已经快两年了,之前一直没怎么关注,直到最近几个月才看了一些 C++11 的新特性,今后几篇博客我都会写一些关于 C++11 的特性,算是记录一下自己学到的东西吧,和大家共勉. 相信 Linux 程序员都用过 Pthread, 但有了 C++11 的 std::thread 以后,你可以在语言层面编写多线程程序了,直接的好处就是多线程程序的可移植性得到了很大的提高,所以作为一名 C++ 程序员,熟悉 C++11 的多线程编程方式还是很有益处的. 如果你对 C++11

  • C++多线程编程简单实例

    C++本身并没有提供任何多线程机制,但是在windows下,我们可以调用SDK win32 api来编写多线程的程序,下面就此简单的讲一下: 创建线程的函数 复制代码 代码如下: HANDLE CreateThread(     LPSECURITY_ATTRIBUTES lpThreadAttributes, // SD     SIZE_T dwStackSize,                       // initial stack size     LPTHREAD_START_

  • C/C++ 多线程的学习心得总结

    个人觉得在学习多线程编程之前最好先了解进程和线程的关系, 然后在学习线程工作方式的过程中动手写个(我是从抄开始的)多线程的小程序, 会对学习多线程有很大的帮助, 否则只有理论是很抽象的. 在学习多线程编程之前, 必须先知道什么是 线程函数, 线程函数就是另一个线程的入口函数. 默认情况下一个我们所写的代码都是只有一个线程的, 而这个线程的入口函数就是main() 函数, 这是系统默认的. 而我们创建的另一个线程也需要一个函数来进入, 这个函数就叫做线程函数. 在C/C++中, 可以调用 '运行期

  • 快速了解Boost.Asio 的多线程模型

    Boost.Asio 有两种支持多线程的方式,第一种方式比较简单:在多线程的场景下,每个线程都持有一个io_service,并且每个线程都调用各自的io_service的run()方法. 另一种支持多线程的方式:全局只分配一个io_service,并且让这个io_service在多个线程之间共享,每个线程都调用全局的io_service的run()方法. 每个线程一个 I/O Service 让我们先分析第一种方案:在多线程的场景下,每个线程都持有一个io_service (通常的做法是,让线程

  • c++11&14-多线程要点汇总

    在C++11以前,C++的多线程编程均需依赖系统或第三方接口实现,一定程度上影响了代码的移植性.C++11中,引入了boost库中的多线程部分内容,形成C++标准,形成标准后的boost多线程编程部分接口基本没有变化,这样方便了以前使用boost接口开发的使用者切换使用C++标准接口,很容易把boost接口升级为C++标准接口. 我们通过如下几部分介绍C++11多线程方面的接口及使用方法. 1. std::thread std::thread为C++11的线程类,使用方法和boost接口一样,非

  • c++11&14-智能指针要点汇总

    学c++的人都知道,在c++里面有一个痛点,就是动态内存的管理,就我所经历的一些问题来看,很多莫名其妙的问题,最后都发现是内存管理不当引起的. 但像java等其他一些语言则不会有这样的问题,为什么呢,因为它们有很好的处理内存的方法,比如java的垃圾回收机制,现在,我们c++终于也有了智能指针. 1. 什么是智能指针 简单地说,智能指针是用对象去管理一个资源指针,同时用一个计数器计算引用当前指针对象的个数,当管理指针的对象增加或减少时,计数器也相应加1或减1,当最后一个指针管理对象销毁时,计数器

  • c++11&14-STL要点汇总

    在c++里面不得不提的一个标准库,就是STL,STL包含很多实用的数据结构,如vector,list,map,set等都是我们常用的,而c++11也对STL做了一些补充,使得STL的内容越来越丰富,可选择的也越来越多了. 1. std::array 先看一段代码: #include <array> #include <iostream> int main() { std::array<int, 4> arrayDemo = { 1,2,3,4 }; std::cout

  • Mysql 5.7.14 使用常见问题汇总(推荐)

    Mysql 5.7.14 使用常见问题汇总(推荐)

    常见问题汇总: 一. 当我们用navicate premiun 连接远程数据库时,若出现如下问题: 笔者结合自己的实践,总结有如下原因: 1.远程数据库服务没有打开连接端口 2.本机IP地址没有得到授权 3.本地网络故障 笔者的情况属于第二种情况,当更换IP访问时,就可以连接成功. 以上所述是小编给大家介绍的Mysql 5.7.14使用常见问题汇总,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的.在此也非常感谢大家对我们网站的支持!

  • JAVA多线程知识汇总

    线程概念 进程:启动一个应用程序就叫一个进程. 接着又启动一个应用程序,这叫两个进程.每个进程都有一个独立的内存空间:进程也是程序的一次执行过程,是系统运行程序的基本单位:系统运行一个程序即是一个进程从创建.运行到消亡的过程. 线程:线程是在进程内部同时做的事情,一个进程中可以有多个线程,这个应用程序也可以称之为多线程程序. 一个程序运行后至少有一个进程,一个进程中可以包含多个线程 线程调度: 分时调度:所有线程轮流使用 CPU 的使用权,平均分配每个线程占用 CPU 的时间. 抢占式调度:优先

  • C++11中多线程编程-std::async的深入讲解

    前言 C++11中提供了异步线程接口std::async,std::async是异步编程的高级封装,相对于直接使用std::thread,std::async的优势在于: 1.std::async会自动创建线程去调用线程函数,相对于低层次的std::thread,使用起来非常方便: 2.std::async返回std::future对象,通过返回的std::future对象我们可以非常方便的获取到线程函数的返回结果: 3.std::async提供了线程的创建策略,可以指定同步或者异步的方式去创建

  • C++11 thread多线程编程创建方式

    C++11 thread多线程编程创建方式

    目录 1 线程创建与结束 线程的创建方式: 线程的结束方式: 2 互斥锁 <mutex> 头文件介绍 std::mutex 介绍 std::mutex 的成员函数 std::lock_guard std::unique_lock 示例: 原子变量 线程同步通信 线程死锁 1 线程创建与结束 C++11 新标准中引入了四个头文件来支持多线程编程,他们分别是<atomic> ,<thread>,<mutex>,<condition_variable>

  • C++11, 14, 17对tuple元素的访问详情

    目录 C++11, 14, 17对tuple元素的访问 std::tuple大总结 元组的使用 典型使用 C++11, 14, 17对tuple元素的访问 std::tuple 作为可以存放任意个数,任意类型的元祖被我个人经常使用. 记得以前看侯捷谈到这个数据结构的时候,被他的实现所惊奇,太巧妙地设计. 我自己在使用std::tuple的时候也随着C++版本的更新尝试新的写法,对于元组中元素的获取,我一直觉得很有意思: 比如我有这么一个源文件: #include <iostream> #inc

  • C++11/14 线程的创建与分离的实现

    线程的创建 让我们看看示例代码(t1.cpp). #include <iostream> #include <thread> void thread_function() { std::cout << "thread function\n"; } int main() { std::thread t(&thread_function); // 线程 t 开始运行 std::cout << "main thread\n&q

  • C++11/14 线程中使用Lambda函数的方法

    多线程中使用lambda 在本篇文章中,主要介绍lambda函数在多线程中的使用. 先从下面的例子开始吧: #include <iostream> #include <thread> int main() { std::thread t([]() { std::cout << "thread function\n"; }); std::cout << "main thread\n"; t.join(); return

随机推荐