C++——多线程编程（一）std::thread

最新推荐文章于 2024-09-14 07:30:00 发布
最新推荐文章于 2024-09-14 07:30:00 发布
阅读量378 收藏
点赞数
分类专栏： 操作系统

转载自：https://blog.csdn.net/shanshangyouzhiyangM/article/details/52986185

（一）与C++11多线程相关的头文件

C++11 新标准中引入了四个头文件来支持多线程编程，他们分别是< atomic> ,< thread>,< mutex>,< condition_variable>和< future>。 
•< atomic>：该头文主要声明了两个类, std::atomic 和 std::atomic_flag，另外还声明了一套 C 风格的原子类型和与 C 兼容的原子操作的函数。 
•< thread>：该头文件主要声明了 std::thread 类，另外 std::this_thread 命名空间也在该头文件中。 
•< mutex>：该头文件主要声明了与互斥量(mutex)相关的类，包括 std::mutex 系列类，std::lock_guard, std::unique_lock, 以及其他的类型和函数。 
•< condition_variable>：该头文件主要声明了与条件变量相关的类，包括 std::condition_variable 和 std::condition_variable_any。 
•< future>：该头文件主要声明了 std::promise, std::package_task 两个 Provider 类，以及 std::future 和 std::shared_future 两个 Future 类，另外还有一些与之相关的类型和函数，std::async() 函数就声明在此头文件中。

（二）std::thread

0

0.1 线程状态

在一个线程的生存期内，可以在多种状态之间转换，不同的操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态，但大体来说，如下几种状态是通用的：

1）就绪：参与调度，等待被执行，一旦被调度选中，立即开始执行

2）运行：占用CPU，正在运行中

3）休眠：暂不参与调度，等待特定事件发生

4）中止：已经运行完毕，等待回收线程资源

0.2 线程环境

线程存在于进程之中，进程内所有全局资源对于内部每个线程都是可见的。

进程内典型全局资源如下：

1）代码区：这意味着当前进程空间内所有的可见的函数代码，对于每个线程来说，也是可见的

2）静态存储区：全局变量，静态空间

3）动态存储区：堆空间

线程内典型的局部资源：

1）本地栈空间：存放本线程的函数调用栈，函数内部的局部变量等

2）部分寄存器变量：线程下一步要执行代码的指针偏移量

1 构造、赋值和拷贝

1.1 构造函数

（1）default ：thread() noexcept; 
（2）initialization ：template < class Fn, class… Args> explicit thread (Fn&& fn, Args&&… args); 
（3）copy [deleted] ：thread (const thread&) = delete; 
（4）move ：thread (thread&& x) noexcept;

  1. 默认构造函数，创建一个空的 thread 执行对象。
  2. 初始化构造函数，创建一个 thread对象，该 thread对象可被joinable，新产生的线程会调用 fn 函数，该函数的参数由 args 给出。
  3. 拷贝构造函数(被禁用)，意味着 thread 不可被拷贝构造。
  4. move 构造函数，调用成功之后 x 不代表任何 thread 执行对象。

注意：可被 joinable 的 thread 对象必须在他们销毁之前被主线程 join 或者将其设置为 detached。

栗子：

#include <iostream>
#include <utility>
#include <thread>
#include <chrono>
#include <functional>
#include <atomic>

void f1(int n)
{
    for (int i = 0; i < 5; ++i) 
    {
        std::cout << "Thread " << n << " executing\n";
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

void f2(int& n)
{
    for (int i = 0; i < 5; ++i) {
        std::cout << "Thread 2 executing\n";
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main()
{
    int n = 0;
    std::thread t1; // t1 is not a thread
    std::thread t2(f1, n + 1); // pass by value
    std::thread t3(f2, std::ref(n)); // pass by reference
    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread
    t2.join();
    t4.join();
    std::cout << "Final value of n is " << n << '\n';
}

注意：关于 std::ref 请参考http://tieba.baidu.com/p/1292003201、https://zhidao.baidu.com/question/1240776856100751219.html

Possible output: 

Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 1 executing
Thread 2 executing
Thread 2 executing
Thread 1 executing
Final value of n is 5

1.2 MOVE赋值操作

move (1)：thread& operator= (thread&& rhs) noexcept; 
copy [deleted] (2)：thread& operator= (const thread&) = delete;

  1. move 赋值操作，如果当前对象不可 joinable，需要传递一个右值引用(rhs)给 move 赋值操作；如果当前对象可被 joinable，则 terminate() 报错。 
    注意：关于右值引用请参考文章http://www.ibm.com/developerworks/cn/aix/library/1307_lisl_c11/
  2. 拷贝赋值操作被禁用，thread 对象不可被拷贝。
//#include <stdio.h>
//#include <stdlib.h>

#include <chrono>    // std::chrono::seconds
#include <iostream>  // std::cout
#include <thread>    // std::thread, std::this_thread::sleep_for

void thread_task(int n) {
    std::this_thread::sleep_for(std::chrono::seconds(n));
    std::cout << "hello thread "
        << std::this_thread::get_id()
        << " paused " << n << " seconds" << std::endl;
}

/*
* ===  FUNCTION  =========================================================
*         Name:  main
*  Description:  program entry routine.
* ========================================================================
*/
int main(int argc, const char *argv[])
{
    std::thread threads[5];
    std::cout << "Spawning 5 threads...\n";
    for (int i = 0; i < 5; i++) {
        threads[i] = std::thread(thread_task, i + 1); /******copy********/
    }
    std::cout << "Done spawning threads! Now wait for them to join\n";
    for (auto& t : threads) {
        t.join();
    }
    std::cout << "All threads joined.\n";

    system("pause");
    return EXIT_SUCCESS;
}  /* ----------  end of function main  ---------- */

注意：C++11中的for循环语句http://blog.csdn.net/hackmind/article/details/24271949

2 其他成员函数

2.1 get_id ：获取线程 ID。

参数：none 
返回值：An object of member type thread::id that uniquely identifies the thread (if joinable), or default-constructed (if not joinable)

Returns the thread id.

If the thread object is joinable, the function returns a value that uniquely identifies the thread.

If the thread object is not joinable, the function returns a default-constructed object of member type thread::id.

栗子：

// thread::get_id / this_thread::get_id
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::thread::id, std::this_thread::get_id
#include <chrono>         // std::chrono::seconds

std::thread::id main_thread_id = std::this_thread::get_id();

void is_main_thread() {
  if ( main_thread_id == std::this_thread::get_id() )
    std::cout << "This is the main thread.\n";
  else
    std::cout << "This is not the main thread.\n";
}

int main() 
{
  is_main_thread();
  std::thread th (is_main_thread);
  th.join();
}

output：

This is the main thread.
This is not the main thread.

2.2 joinable ：检查线程是否可被 join。

返回值：false、true 
参数：none

Returns whether the thread object is joinable.

A thread object is joinable if it represents a thread of execution.

A thread object is not joinable in any of these cases: 
•if it was default-constructed. 
•if it has been moved from (either constructing another thread object, or assigning to it). 
•if either of its members join or detach has been called.

栗子：

// example for thread::joinable
#include <iostream>       // std::cout
#include <thread>         // std::thread

void mythread() 
{
  // do stuff...
}

int main() 
{
  std::thread foo;
  std::thread bar(mythread);

  std::cout << "Joinable after construction:\n" << std::boolalpha;
  std::cout << "foo: " << foo.joinable() << '\n';
  std::cout << "bar: " << bar.joinable() << '\n';

  if (foo.joinable()) foo.join();
  if (bar.joinable()) bar.join();

  std::cout << "Joinable after joining:\n" << std::boolalpha;
  std::cout << "foo: " << foo.joinable() << '\n';
  std::cout << "bar: " << bar.joinable() << '\n';

  return 0;
}

Output (after 3 seconds):

Joinable after construction:
foo: false
bar: true
Joinable after joining:
foo: false
bar: false

2.3 join：Join 线程。

参数：none 
返回值：none

The function returns when the thread execution has completed.

直到线程函数被执行完毕，join才返回。This synchronizes the moment this function returns with the completion of all the operations in the thread: This blocks the execution of the thread that calls this function until the function called on construction returns (if it hasn’t yet).

After a call to this function, the thread object becomes non-joinable and can be destroyed safely.

栗子：

// example for thread::join
#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

void pause_thread(int n) 
{
  std::this_thread::sleep_for (std::chrono::seconds(n));
  std::cout << "pause of " << n << " seconds ended\n";
}

int main() 
{
  std::cout << "Spawning 3 threads...\n";
  std::thread t1 (pause_thread,1);
  std::thread t2 (pause_thread,2);
  std::thread t3 (pause_thread,3);
  std::cout << "Done spawning threads. Now waiting for them to join:\n";
  t1.join();
  t2.join();
  t3.join();
  std::cout << "All threads joined!\n";

  return 0;
}

Output (after 3 seconds):

Spawning 3 threads...
Done spawning threads. Now waiting for them to join:
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
All threads joined!

2.4 detach：Detach 线程

参数：none 
返回值：none

Detaches the thread represented by the object from the calling thread, allowing them to execute independently from each other.

Both threads continue without blocking nor synchronizing in any way. Note that when either one ends execution, its resources are released.

After a call to this function, the thread object becomes non-joinable and can be destroyed safely.

栗子：

#include <iostream>       // std::cout
#include <thread>         // std::thread, std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

void pause_thread(int n) 
{
  std::this_thread::sleep_for (std::chrono::seconds(n));
  std::cout << "pause of " << n << " seconds ended\n";
}

int main() 
{
  std::cout << "Spawning and detaching 3 threads...\n";
  std::thread (pause_thread,1).detach();
  std::thread (pause_thread,2).detach();
  std::thread (pause_thread,3).detach();
  std::cout << "Done spawning threads.\n";

  std::cout << "(the main thread will now pause for 5 seconds)\n";
  // give the detached threads time to finish (but not guaranteed!):
  pause_thread(5);
  return 0;
}

Output (after 5 seconds):

Spawning and detaching 3 threads...
Done spawning threads.
(the main thread will now pause for 5 seconds)
pause of 1 seconds ended
pause of 2 seconds ended
pause of 3 seconds ended
pause of 5 seconds ended

detach调用之后，目标线程就成为了守护线程，驻留后台运行，与之关联的std::thread对象失去对目标线程的关联，无法再通过std::thread对象取得该线程的控制权。当线程主函数执行完之后，线程就结束了，运行时库负责清理与该线程相关的资源。

当一个thread对象到达生命期终点而关联线程还没有结束时，则thread对象取消与线程之间的关联，目标线程线程则变为分离线程继续运行搜索。

当调用join函数时，调用线程阻塞等待目标线程终止，然后回收目标线程的资源。

2.5 swap：Swap 线程 。

参数：the thread to swap with  
返回值：none

Exchanges the underlying handles of two thread objects

栗子

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

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar);

    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    std::swap(t1, t2);

    std::cout << "after std::swap(t1, t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    t1.swap(t2);

    std::cout << "after t1.swap(t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

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

Possible output: 

thread 1 id: 1892
thread 2 id: 2584
after std::swap(t1, t2):
thread 1 id: 2584
thread 2 id: 1892
after t1.swap(t2):
thread 1 id: 1892
thread 2 id: 2584

另外：void std::swap( thread &lhs, thread &rhs ); 
说明：不是成员函数。只是重载了std::swap函数。 
用法：std::swap(thread1,thread2); 
栗子：

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

void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

void bar()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main()
{
    std::thread t1(foo);
    std::thread t2(bar);

    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    std::swap(t1, t2);

    std::cout << "after std::swap(t1, t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

    t1.swap(t2);

    std::cout << "after t1.swap(t2):" << std::endl;
    std::cout << "thread 1 id: " << t1.get_id() << std::endl;
    std::cout << "thread 2 id: " << t2.get_id() << std::endl;

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

输出：

thread 1 id: 1892
thread 2 id: 2584
after std::swap(t1, t2):
thread 1 id: 2584
thread 2 id: 1892
after t1.swap(t2):
thread 1 id: 1892
thread 2 id: 2584

2.6 native_handle：返回 native handle。

2.7 hardware_concurrency [static]：检测硬件并发特性。

2.8 总结

http://en.cppreference.com/w/cpp/thread/thread

std::thread m_thrSend; //线程句柄
bool m_sending{ false }; //线程退出标识
bool startSend()
    {
        if (m_sending)
            return false;
        m_sending = true;
        m_thrSend = std::thread([this](){this->thrSend(); });
        return true;
    }
void stopSend()
    {
        m_sending = false;
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        if (m_thrSend.joinable())
            m_thrSend.join();
    }
xy_cpp
关注
专栏目录
C++11中多线程编程-std::async的深入讲解
12-16
C++11引入了std::async作为异步编程的一个高级接口，它简化了多线程编程，特别是对于那些需要在后台执行任务并等待结果的场景。std::async提供了灵活的线程创建策略，并且返回一个std::future对象，使得获取线程函数...
std::thread创建一个带this 的线程
sunfanup的博客
06-08 393
thread
【C++11】线程创建于管理（std::thread）详解
最新发布
byte轻骑兵的博客
09-14 1885
本文详细阐述了如何使用std::thread构造函数创建线程，包括传递函数、函数指针、成员函数、lambda表达式等作为线程的执行体。同时，介绍了线程管理的核心方法，包括join()用于等待线程结束，detach()用于分离线程使其独立运行，以及joinable()用于检查线程是否可被join或detach。
C++11多线程std::thread
Lyu-ming 栏目
07-12 1546
在C++11之前，多线程我们一般使用ptread库。C++11提供了一个很好用于线程操作的标准库std::thread，编码时需引入头文件#include，std::thread在linux下调用的是原有的pthread api实现线程操作，因此编译时需加上lpthread库。 1. 默认构造函数 thread() noexcept： 默认构造函数，创建一个空的 std::thread 执行对象。...
std::thread和std::this_thread的详细说明
咸鱼爱幻想的博客
03-11 3818
std::thread类来表示执行的各个线程。执行线程是实际上是执行一系列指令，可以在多线程环境中与其他此类序列同时执行，同时共享相同的地址空间。 std::this_thread命名空间包含了对当前线程的一些基本操作，如获取当前线程id、休眠当前线程、让渡当前线程的时间片给其他线程等。
C++多线程，创建线程std::thread
m0_37542524的博客
01-19 1520
#include <iostream> #include <thread> #include <unistd.h> #include <map> class A { private: int m_a = 100; std::thread m_t; bool m_run_flag = true...
c++11多线程编程之std::async的介绍与实例
12-16
总结来说，`std::async`是C++11多线程编程中一个强大的工具，它简化了异步任务的管理，提供了灵活的启动策略，并且能够方便地与`std::future`结合使用，以获取异步任务的结果。通过合理利用`std::async`，开发者可以...
C++11并发编程:多线程std::thread
08-26
C++11并发编程：多线程std::thread C++11引入了thread类，大大降低了多线程使用的复杂度。原先使用多线程只能用系统的API，无法解决跨平台问题，一套代码平台移植，对应多线程代码也必须要修改。现在在C++11中只需...
C++11 并发指南之std::thread 详解
08-25
"C++11 并发指南之std::thread 详解" 本文主要介绍了 C++11 中的 std::thread 类...std::thread 类是 C++11 并发指南的重要组件，它提供了创建和管理线程的功能，允许开发者在程序中创建多个线程，从而实现并发编程。
std::thread 创建线程的几种方式
半雨微凉
04-18 8452
简介 本文主要介绍标准C++中 thread的创建线程的几种方式。 使用时需要加头文件： #include <thread> 位于std命名空间中，是跨平台的线程操作 使用说明 1、通过函数指针创建 一般来说，像CreateThread、_beginthread等创建线程时，都会先写一个含有一个参数（LPVOID lpParam）的全局函数，用于通过函数指针创建线程...
std::bind和std::thread使用
CSDN爱好者的独到见解
09-29 1218
在这个例子中，我们使用std::bind创建了一个新的函数对象add5，它将add函数的第一个参数绑定到了值5上。std::bind是一个c++标准库函数模板，通过将参数绑定到可调用实体(函数或成员函数)，用于创建可调用对象(函数对象)。在这个例子中，我们使用std::bind创建了一个新的函数对象subtractReordered，它在调用subtract函数时交换了参数的顺序。无论绑定的是类成员函数还是非成员函数，std::bind都允许自定义参数，重新排序，并使用特定的参数绑定创建可调用对象。
C/C++编程：std::thread 详解
OceanStar的博客
07-15 1万+
上一篇博客《C++11 并发指南一(C++11 多线程初探)》中只是提到了 std::thread 的基本用法，并给出了一个最简单的例子，本文将稍微详细地介绍 std::thread 的用法。 std::thread 在 <thread>头文件中声明，因此使用 std::thread 时需要包含 <thread> 头文件。 std::thread 构造 default (1) thread() noexcept; initialization (2) temp
std::this_thread
darren_pty
09-12 459
std::this_thread
C++ std::thread使用
mayue_web的博客
10-16 1万+
C++ std::thread 使用
C++：std::thread：线程用法
C++ JAVA的专栏
01-06 7980
C++：std::thread：线程用法
C++std::thread
qq_44875284的博客
03-31 2767
简单介绍thread的用法
C++11 多线程支持之std::thread
热门推荐
逗神大人的博客
01-03 2万+
从C++11开始，C++标准库已经支持了线程库了，其实在底层，仍旧使用的是平台相关的线程API 有了std::thread之后，我们就不用在不同的平台使用不同的API了，比如Unix平台使用pthread， windows平台使用WinSDK的CreateThread了，接口使用去掉了平台差异性，使得项目开发具有更好的移植性1. std::thread的使用方法A. 所需头文件#include <
c++ 多线程std::thread总结
weixin_45626706的博客
09-30 2329
c++多线程
c++在多线程std::thread中std::bind
10-14
在多线程std::thread中使用std::bind可以将函数和参数绑定到一个可调用对象中，方便在多线程中使用。例如： ``` void foo(int a, int b) { // do something } int main() { std::thread t(std::bind(foo, 1, 2))...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值