最近技术上没什么大的收获，也是悲催的路过~

搞一点新东西压压惊吧！

C++11并发之std::thread

知识链接：
C++11 并发之std::atomic
 
本文概要：
1、成员类型和成员函数。
 
2、std::thread 构造函数。
3、异步。
4、多线程传递参数。
5、join、detach。
6、获取CPU核心个数。
7、CPP原子变量与线程安全。
8、lambda与多线程。
9、时间等待相关问题。
10、线程功能拓展。
11、多线程可变参数。
12、线程交换。
13、线程移动。
 
std::thread 在 #include<thread> 头文件中声明，因此使用 std::thread 时需要包含 #include<thread> 头文件。
 
1、成员类型和成员函数。
成员类型：
id
Thread id (public member type )                                       id
native_handle_type
Native handle type (public member type )

成员函数：

(constructor)
Construct thread (public member function )        构造函数
(destructor)
Thread destructor (public member function )      析构函数
operator=
Move-assign thread (public member function )  赋值重载
get_id
Get thread id (public member function )                获取线程id
joinable
Check if joinable (public member function )          判断线程是否可以加入等待
join
Join thread (public member function )                    加入等待
detach
Detach thread (public member function )              分离线程
swap
Swap threads (public member function )               线程交换
native_handle
Get native handle (public member function )       获取线程句柄
hardware_concurrency [static]
Detect hardware concurrency (public static member function )   检测硬件并发特性

Non-member overloads：

swap (thread)
Swap threads (function )
 
2、std::thread 构造函数。
如下表：
default (1)
thread() noexcept;
initialization(2)
template <class Fn, class... Args>   explicit thread (Fn&& fn, Args&&... args);
copy [deleted] (3)
thread (const thread&) = delete;
move [4]
hread (thread&& x) noexcept;
(1).默认构造函数，创建一个空的 thread 执行对象。
(2).初始化构造函数，创建一个 thread 对象，该 thread 对象可被 joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。
(3).拷贝构造函数（被禁用），意味着 thread 不可被拷贝构造。
(4).move 构造函数，move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。
注意：可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached。
 
std::thread 各种构造函数例子如下：
#include<thread>

#include<chrono>

using namespace std;

void fun1(int n)  //初始化构造函数

{

    cout << "Thread " << n << " executing\n";

    n += ;

    this_thread::sleep_for(chrono::milliseconds());

}

void fun2(int & n) //拷贝构造函数

{

    cout << "Thread " << n << " executing\n";

    n += ;

    this_thread::sleep_for(chrono::milliseconds());

}

int main()

{

    int n = ;

    thread t1;               //t1不是一个thread

    thread t2(fun1, n + );  //按照值传递

    t2.join();

    cout << "n=" << n << '\n';

    n = ;

    thread t3(fun2, ref(n)); //引用

    thread t4(move(t3));     //t4执行t3，t3不是thread

    t4.join();

    cout << "n=" << n << '\n';

    return ;

}

运行结果:

Thread  executing

n=

Thread  executing

n=</span>
3、异步。
例如：
 
#include<thread>

using namespace std;

void show()

{

    cout << "hello cplusplus!" << endl;

}

int main()

{

    //栈上

    thread t1(show);   //根据函数初始化执行

    thread t2(show);

    thread t3(show);

    //线程数组

    thread th[]{thread(show), thread(show), thread(show)};

    //堆上

    thread *pt1(new thread(show));

    thread *pt2(new thread(show));

    thread *pt3(new thread(show));

    //线程指针数组

    thread *pth(new thread[]{thread(show), thread(show), thread(show)});

    return ;

}
4、多线程传递参数。
例如：
#include<thread>

using namespace std;

void show(const char *str, const int id)

{

    cout << "线程 " << id +  << " ：" << str << endl;

}

int main()

{

    thread t1(show, "hello cplusplus!", );

    thread t2(show, "你好，C++！", );

    thread t3(show, "hello!", );

    return ;

}

运行结果：

线程 1线程  ：你好，C++！线程  ：hello!

：hello cplusplus!
发现，线程 t1、t2、t3 都执行成功！
 
5、join、detach。
join例子如下：
#include<thread>

#include<array>

using namespace std;

void show()

{

    cout << "hello cplusplus!" << endl;

}

int main()

{

    array<thread, >  threads = { thread(show), thread(show), thread(show) };

    for (int i = ; i < ; i++)

    {

        cout << threads[i].joinable() << endl;//判断线程是否可以join

        threads[i].join();//主线程等待当前线程执行完成再退出

    }

    return ;

}

运行结果:

hello cplusplus!

hello cplusplus!  

hello cplusplus!
总结：
join 是让当前主线程等待所有的子线程执行完，才能退出。
detach例子如下：
#include<thread>

using namespace std;

void show()

{

    cout << "hello cplusplus!" << endl;

}

int main()

{

    thread th(show);

    //th.join();

    th.detach();//脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。

    //detach以后，子线程会成为孤儿线程，线程之间将无法通信。

    cout << th.joinable() << endl;

    return ;

}

运行结果:

hello cplusplus!
结论：
线程 detach 脱离主线程的绑定，主线程挂了，子线程不报错，子线程执行完自动退出。
线程 detach以后，子线程会成为孤儿线程，线程之间将无法通信。
 
6、获取CPU核心个数。
例如：
#include<thread>

using namespace std;

int main()

{

    auto n = thread::hardware_concurrency();//获取cpu核心个数

    cout << n << endl;

    return ;

}

运行结果:
结论：
通过  thread::hardware_concurrency() 获取 CPU 核心的个数。
 
7、CPP原子变量与线程安全。
问题例如：
#include<thread>

using namespace std;

const int N = ;

int num = ;

void run()

{

    for (int i = ; i < N; i++)

    {

        num++;

    }

}

int main()

{

    clock_t start = clock();

    thread t1(run);

    thread t2(run);

    t1.join();

    t2.join();

    clock_t end = clock();

    cout << "num=" << num << ",用时 " << end - start << " ms" << endl;

    return ;

}

运行结果:

num=,用时  ms
从上述代码执行的结果，发现结果并不是我们预计的200000000，这是由于线程之间发生冲突，从而导致结果不正确。
为了解决此问题，有以下方法：
（1）互斥量。
例如：
#include<thread>

#include<mutex>

using namespace std;

const int N = ;

int num();

mutex m;

void run()

{

    for (int i = ; i < N; i++)

    {

        m.lock();

        num++;

        m.unlock();

    }

}

int main()

{

    clock_t start = clock();

    thread t1(run);

    thread t2(run);

    t1.join();

    t2.join();

    clock_t end = clock();

    cout << "num=" << num << ",用时 " << end - start << " ms" << endl;

    return ;

}

运行结果：

num=,用时  ms
不难发现，通过互斥量后运算结果正确，但是计算速度很慢，原因主要是互斥量加解锁需要时间。
互斥量详细内容 请参考C++11 并发之std::mutex。
（2）原子变量。
例如：
#include<thread>

#include<atomic>

using namespace std;

const int N = ;

atomic_int num{  };//不会发生线程冲突，线程安全

void run()

{

    for (int i = ; i < N; i++)

    {

        num++;

    }

}

int main()

{

    clock_t start = clock();

    thread t1(run);

    thread t2(run);

    t1.join();

    t2.join();

    clock_t end = clock();

    cout << "num=" << num << ",用时 " << end - start << " ms" << endl;

    return ;

}

运行结果:

num=,用时  ms
不难发现，通过原子变量后运算结果正确，计算速度一般。
原子变量详细内容 请参考C++11 并发之std::atomic。
（3）加入 join 。
例如：
#include<thread>

using namespace std;

const int N = ;

int num = ;

void run()

{

    for (int i = ; i < N; i++)

    {

        num++;

    }

}

int main()

{

    clock_t start = clock();

    thread t1(run);

    t1.join();

    thread t2(run);

    t2.join();

    clock_t end = clock();

    cout << "num=" << num << ",用时 " << end - start << " ms" << endl;

    return ;

}

运行结果：

num=,用时  ms
不难发现，通过原子变量后运算结果正确，计算速度也很理想。
 
8、lambda与多线程。
例如：
#include<thread>

using namespace std;

int main()

{

    auto fun = [](const char *str) {cout << str << endl; };

    thread t1(fun, "hello world!");

    thread t2(fun, "hello beijing!");

    return ;

}

运行结果：

hello world!

hello beijing!
9、时间等待相关问题。
例如：
#include<thread>

#include<chrono>

using namespace std;

int main()

{

    thread th1([]()

    {

        //让线程等待3秒

        this_thread::sleep_for(chrono::seconds());

        //让cpu执行其他空闲的线程

        this_thread::yield();

        //线程id

        cout << this_thread::get_id() << endl;

    });

    return ;

}
10、线程功能拓展。
例如：
#include<thread>

using namespace std;

class MyThread :public thread   //继承thread

{

public:

    //子类MyThread()继承thread()的构造函数

    MyThread() : thread()

    {

    }

    //MyThread()初始化构造函数

    template<typename T, typename...Args>

    MyThread(T&&func, Args&&...args) : thread(forward<T>(func), forward<Args>(args)...)

    {

    }

    void showcmd(const char *str)  //运行system

    {

        system(str);

    }

};

int main()

{

    MyThread th1([]()

    {

        cout << "hello" << endl;

    });

    th1.showcmd("calc"); //运行calc

    //lambda

    MyThread th2([](const char * str)

    {

        cout << "hello" << str << endl;

    }, " this is MyThread");

    th2.showcmd("notepad");//运行notepad

    return ;

}

运行结果:

hello

//运行calc

hello this is MyThread

//运行notepad
11、多线程可变参数。
例如：
#include<thread>

#include<cstdarg>

using namespace std;

int show(const char *fun, ...)

{

    va_list ap;//指针

    va_start(ap, fun);//开始

    vprintf(fun, ap);//调用

    va_end(ap);

    return ;

}

int main()

{

    thread t1(show, "%s    %d    %c    %f", "hello world!", , 'A', 3.14159);

    return ;

}

运行结果：

hello world!        A    3.14159
12、线程交换。
例如：
#include<thread>

using namespace std;

int main()

{

    thread t1([]()

    {

        cout << "thread1" << endl;

    });

    thread t2([]()

    {

        cout << "thread2" << endl;

    });

    cout << "thread1' id is " << t1.get_id() << endl;

    cout << "thread2' id is " << t2.get_id() << endl;  

    cout << "swap after:" << endl;

    swap(t1, t2);//线程交换

    cout << "thread1' id is " << t1.get_id() << endl;

    cout << "thread2' id is " << t2.get_id() << endl;

    return ;

}

运行结果:

thread1

thread2

thread1' id is 4836

thread2' id is 4724

swap after:

thread1' id is 4724

thread2' id is 4836
两个线程通过 swap 进行交换。
 
13、线程移动。
例如：
#include<thread>

using namespace std;

int main()

{

    thread t1([]()

    {

        cout << "thread1" << endl;

    });

    cout << "thread1' id is " << t1.get_id() << endl;

    thread t2 = move(t1);;

    cout << "thread2' id is " << t2.get_id() << endl;

    return ;

}

运行结果:

thread1

thread1' id is 5620

thread2' id is 5620

从上述代码中，线程t2可以通过 move 移动 t1 来获取 t1 的全部属性，而 t1 却销毁了。

原贴地址：https://www.cnblogs.com/lidabo/p/7852033.html

C++11并发之std::thread<转>的更多相关文章

  1. c++11并发之std::thread

    知识链接: https://www.cnblogs.com/lidabo/p/7852033.html 构造函数如下: ) thread() noexcept; initialization() te ...

  2. C++11 并发之std::thread std::mutex

    https://www.cnblogs.com/whlook/p/6573659.html (https://www.cnblogs.com/lidabo/p/7852033.html) C++:线程 ...

  3. C++11并发之std::mutex

    知识链接: C++11并发之std::thread   本文概要: 1. 头文件. 2.std::mutex. 3.std::recursive_mutex. 4.std::time_mutex. 5 ...

  4. C++11 并发指南------std::thread 详解

    参考: https://github.com/forhappy/Cplusplus-Concurrency-In-Practice/blob/master/zh/chapter3-Thread/Int ...

  5. C++11并发——多线程std::thread （一）

    https://www.cnblogs.com/haippy/p/3284540.html 与 C++11 多线程相关的头文件 C++11 新标准中引入了四个头文件来支持多线程编程,他们分别是< ...

  6. c++11中关于std::thread的join的思考

    c++中关于std::thread的join的思考 std::thread是c++11新引入的线程标准库,通过其可以方便的编写与平台无关的多线程程序,虽然对比针对平台来定制化多线程库会使性能达到最大, ...

  7. c++11中关于`std::thread`线程传参的思考

    关于std::thread线程传参的思考 最重要要记住的一点是:参数要拷贝到线程独立内存中,不管是普通类型.还是引用类型. 对于传递参数是引用类型,需要注意: 1.当指向动态变量的指针(char *) ...

  8. C++ 11 笔记 （五） ： std::thread

    这真是一个巨大的话题.我猜记录完善绝B需要一本书的容量. 所以..我只是略有了解,等以后用的深入了再慢慢补充吧. C++写多线程真是一个痛苦的事情,当初用过C语言的CreateThread,见过boo ...

  9. Cocos2dx 3.0 过渡篇（二十六）C++11多线程std::thread的简单使用(上)

    昨天练车时有一MM与我交替着练,聊了几句话就多了起来,我对她说:"看到前面那俩教练没?老色鬼两枚!整天调戏女学员."她说:"还好啦,这毕竟是他们的乐趣所在,你不认为教练每 ...

随机推荐

  1. mysql查询优化之二：查询优化器的局限性

    在<mysql查询优化之一:mysql查询优化常用方式>一文中列出了一些优化器常用的优化手段.查询优化器在提供这些特性的同时,也存在一定的局限性,这些局限性往往会随着MySQL版本的升级而 ...

  2. AWS机器学习初探（1）：Comprehend - 自然语言处理服务

    AWS机器学习初探(1):Comprehend - 自然语言处理服务 1. Comprehend 服务简介 1.1 功能 Amazon Comprehend 服务利用自然语言处理(NLP)来分析文本. ...

  3. 学习笔记之The Intelligent Investor, Rev. Ed

    The Intelligent Investor, Rev. Ed https://www.safaribooksonline.com/library/view/the-intelligent-inv ...

  4. 廖雪峰Java6IO编程-1IO基础-1IO简介

    1.IO简介 IO是指Input/Output,即输入和输出: Input指从外部读取数据到内存,例如从磁盘读取,从网络读取. * 为什么要把数据读到内存才能处理这些数据呢? * 因为代码是在内存中运 ...

  5. python图片和字符串的转换

    有个业务,需要将图片压缩转化为64位编码上传到服务端. import json,requests,base64 #网上下载图片素材 r = requests.get("https://tim ...

  6. oracle em管理平台

      检查em有没有打开     https://172.30.2.120:1158/em/console/logon/logon   输入你配置的账号密码       界面如下图所示  

  7. MySQL 独立表空间恢复案例

    创建表的时候就会得到元数据.可以通过定义的方式对表的元数据进行生成 这个地方要注意的是 独立表空间当中   ibd & frm分别存储的是什么数据? 表空间:文件系统,为了更好的扩容数据库的存 ...

  8. sas spawner

    注册spawner 服务"c:\Program Files\SASHome\SASFoundation\9.4\cntspawn.exe" -install -service 51 ...

  9. C#语言时间

    string x = "abcdefg"; 定义字符串 int length = x.Length; 定义长度 string y = x.Substring(1, 2); 意思的从 ...

  10. (转)C# WebApi 身份认证解决方案：Basic基础认证

    原文地址:http://www.cnblogs.com/landeanfen/p/5287064.html 阅读目录 一.为什么需要身份认证 二.Basic基础认证的原理解析 1.常见的认证方式 2. ...